Using Linkly AI CLI

Introduction to Linkly AI CLI

Linkly AI CLI is a command-line tool that connects to Linkly AI Desktop’s MCP service, allowing you to search, browse, and read local documents from the terminal. It also serves as a bridge between AI Agents (such as Claude Desktop, Cursor) and Linkly AI.

Terminal Search

Search your documents directly from the command line — ideal for developers and power users

MCP Bridge

Run in stdio MCP mode, enabling Claude Desktop, Cursor, and other AI tools to call Linkly AI

Installation

macOS / Linux
Windows
Cargo

Run in your terminal:

curl -sSL https://updater.linkly.ai/cli/install.sh | sh

Or install via Homebrew:

brew tap LinklyAI/tap
brew install linkly

Run in PowerShell:

irm https://updater.linkly.ai/cli/install.ps1 | iex

Install from crates.io (requires Rust toolchain):

cargo install linkly-ai-cli

If you already have Linkly AI Desktop, you can also install the CLI from the desktop app: click Install on the Connect an agent screen of the first-run wizard, which installs both the CLI and Skills; or click Install in the Linkly AI CLI row in the Advanced section of the Agent usage page in the main window. If One last step pops up, click Set up so your terminal can run the linkly command directly.

After installation, verify the installation:

linkly --version

By default, the CLI discovers and connects to the local Linkly AI Desktop app via ~/.linkly/port. You can also connect to a remote device via LAN or the cloud tunnel — see Connection Modes below.

Usage

The CLI follows a search → grep or outline → read progressive workflow: first search to find target documents, then use grep to find patterns or view the outline to understand the structure, and finally read the specific content. When the user describes a container (“in my Notion notes”, “in my Dropbox papers folder”) whose actual path is unknown, call find-paths before search to discover the path.

Every successful command output ends with a [meta] now=2026-05-08T...Z UTC timestamp line (or a top-level _meta.now field in JSON mode). This is metadata Desktop provides to AI assistants for computing relative dates like “last month” — human users can ignore it; for scripting, you may want to filter out the last line before further parsing.

Check Connection Status

linkly status

Returns the running status, version number, number of indexed documents, and indexing status of Linkly AI Desktop.

Search Documents

linkly search "keywords or phrases"

Searches your local documents and returns the most relevant results, including title, path, relevance score, and content snippet. Common parameters:

# Limit the number of results (default 20, max 50)
linkly search "API design" --limit 5

# Filter by document type
linkly search "meeting minutes" --type pdf,docx

# Output in JSON format (suitable for scripting)
linkly search "budget report" --json

# Limit by time window (Q3 2024 quarterly reports)
linkly search "quarterly report" --modified-after 2024-07-01 --modified-before 2024-09-30

# Sort by time ("the latest", "the earliest" — when there's no fixed window)
linkly search "weekly retro" --time-sort newest --limit 5

# Search audio and video by what was said in them
linkly search "we decided to postpone" --type audio,video

# Search your notes instead of your files
linkly search "onboarding checklist" --scope notes

--modified-after / --modified-before accept ISO 8601 UTC: a bare date 2024-01-01 (treated as 00:00:00Z) or a full RFC 3339 timestamp 2024-01-01T00:00:00Z. --time-sort accepts newest / oldest; omit it to keep the default BM25 + vector relevance order.

--scope notes restricts results to your notes and ignores --library and --path-glob — those filters are silently dropped rather than rejected.

View Document Outline

linkly outline <DOC_ID>

Retrieves the structured outline and metadata of a document. DOC_ID is obtained from search results. You can view multiple documents at once, or pipe the IDs in with -:

linkly outline id1 id2 id3

# Outline everything a search found, without a shell loop
linkly search "architecture" --json | jq -r '.results[].doc_id' | linkly outline -

When an outline is long, some nodes are collapsed. Use --expand to name the node IDs to expand, comma-separated; all other nodes stay collapsed. Without it, the CLI decides automatically which nodes to expand:

linkly outline <DOC_ID> --expand 2,3.1

The outline feature works best with Markdown, DOCX, DOC, PowerPoint (PPTX), XLSX, CSV, EPUB, and RTF documents, as their heading structures can be parsed. For plain text or PDFs without bookmarks, it’s recommended to use the read command directly.

Search Patterns in Documents

linkly grep <PATTERN> <DOC_ID>...

Search for regex pattern matches inside one or more documents. Use when you need to find specific text (terms, names, dates, identifiers, etc.):

# Find a pattern in a document
linkly grep "useState" 456

# Case-insensitive with context lines
linkly grep "error|warning" 1044 -C 3 -i

# Count matches only
linkly grep "TODO" 591 --mode count

# Paginate matches (skip first 20, show next 20)
linkly grep "import" 302 --offset 20 --limit 20

# Grep across everything a search found
linkly search "deployment" --json | jq -r '.results[].doc_id' \
  | linkly grep "docker|kubernetes" -

Read Document Content

linkly read <DOC_ID>...

Reads the full content of one or more documents, outputting text with line numbers. For long documents, you can read in pages:

# Start from line 50, read 100 lines
linkly read <DOC_ID> --offset 50 --limit 100

# Include the OCR text of images referenced in the page
linkly read <DOC_ID> --image-text full

# Read several documents at once, or pipe the IDs in
linkly read id1 id2 id3
linkly search "onboarding" --json | jq -r '.results[].doc_id' | linkly read -

With --json, several documents print as JSON Lines — one object per line. A single ID still prints a single object, so existing scripts are unaffected.

Pagination strategy: By default, 200 lines are read per request (max 500 lines). For long documents, adjust --offset to read progressively:

linkly read <DOC_ID> --offset 1 --limit 200    # Lines 1-200
linkly read <DOC_ID> --offset 201 --limit 200  # Lines 201-400
linkly read <DOC_ID> --offset 401 --limit 200  # Lines 401-600

Find Paths (find-paths)

linkly find-paths --patterns <keyword,keyword,...>

Fuzzy-matches keywords against the file path field of indexed documents, aggregates matches at folder granularity, and returns the top folder candidates. It is positioned as a helper for search: when the user names a container (“in my Notion notes”, “in my Dropbox papers folder”) but you don’t know its on-disk path, call find-paths first, then pass a distinctive segment of the returned path to search as --path-glob. When a folder name contains glob metacharacters (* ? [), use the returned path_glob field directly — it is already escaped to match that folder literally. Two-step workflow:

# Step 1: locate the real path
linkly find-paths --patterns Notion,notion --limit 5
# Suppose it returns .../Documents/Notion-Export-abc/workspace (1240 files)

# Step 2: search within that container
linkly search "shopping receipt" --path-glob "*Notion-Export*"

Variant matching: --patterns takes a comma-separated list of keywords, OR-matched against the path. Pass several variants in one call (translation pairs, casing, real app/SDK identifiers when known) to maximise first-pass recall:

linkly find-paths --patterns Notion,notion,Notion-Export
linkly find-paths --patterns Slack,slack --library work-notes

find-paths is a “find folders” tool, not a “find files” tool: only matches on directory segments count. If keywords match only the filename segment (an “orphan file”), they are silently dropped. If a query returns zero folders even though you expect matching files, fall back to calling linkly search directly without --path-glob.

Libraries and Overview (list-libraries, explore)

linkly list-libraries

Lists the available libraries. The library names it returns can be used in the --library option of other commands.

linkly explore
linkly explore --library work-notes

Gives an overview of all your documents or of a single library — useful for getting a sense of what’s there before you search. --library accepts a library name or local://<id>; with --remote you can also pass cloud://<owner>/<slug>.

Notes

Linkly AI keeps short Markdown notes in your library folder. They are ordinary local files — never uploaded — and they are indexed like any other document.

# List them, newest first
linkly list --scope notes

# Filter by tag
linkly list --scope notes --tags project,urgent

# Write one
linkly note-save --mode create --content "Remember to renew the certificate" --tags ops

# Pipe a long body in instead of quoting it
some-command | linkly note-save --mode create --content -

Editing an existing note needs its note_id and current version, both of which linkly list --scope notes returns:

linkly note-save --mode edit \
  --note-id <uuid> --base-version <version> \
  --tags ops --content "Updated text"

Inline #tags in the note body are the note’s tags — --tags only adds (remove a tag by deleting its #tag marker from the content). Desktops older than 0.11.0 instead require --tags on edit and treat it as the full replacement set. --base-version is a concurrency check: if the note changed since you read it, the command fails with NOTE_VERSION_CONFLICT instead of overwriting. Note content is a restricted Markdown subset (paragraphs, bold, strikethrough, lists); headings, code, links and tables are rejected.

Diagnose Connections (doctor)

linkly doctor

Checks the connection to the desktop app on this machine, and also any saved remote key or LAN connection. Each connection gets its own group of results, with advice on how to fix any failure. It exits 0 as long as at least one connection works. With --remote, --lan, or --endpoint / --token, it checks only that one connection, and the exit code reflects only that connection:

linkly doctor --remote

Manage Skills (skills)

linkly skills status    # installed version, latest released version, and install location
linkly skills install   # download and install the Skills
linkly skills update    # update the installed Skills, or install them if missing

install puts the Skills in ~/.agents/skills/linkly-ai and creates a link to it at ~/.claude/skills/linkly-ai. See Using Skills for details. When a new version of the Skills is available, the command output ends with a one-line notice, at most once every 4 hours. Set the environment variable LINKLY_NO_SKILLS_HINT=1 to turn it off. Set the variable in your MCP client’s configuration and the linkly mcp bridge stops showing it too.

Shell Completions

linkly completions <SHELL>

Prints a completion script for bash, zsh, fish, powershell or elvish.

zsh
bash
fish
PowerShell

mkdir -p ~/.zfunc
linkly completions zsh > ~/.zfunc/_linkly
# Add to ~/.zshrc if not already there:
#   fpath=(~/.zfunc $fpath)
#   autoload -Uz compinit && compinit

linkly completions bash > /usr/local/etc/bash_completion.d/linkly

linkly completions fish > ~/.config/fish/completions/linkly.fish

linkly completions powershell | Out-String | Invoke-Expression

Open a new shell afterwards. The script is static — it never contacts Linkly AI Desktop, so it works with the app closed and can’t slow down your prompt.

MCP Mode

linkly mcp

Runs as a stdio MCP server, exposing Linkly AI’s tools to MCP-compatible AI clients. The upstream decides what the client can reach:

Command	Reaches
`linkly mcp`	The local desktop app — your local content only
`linkly mcp --remote`	The cloud gateway — local content and linked cloud libraries

--remote is the only bridge mode that can reach cloud libraries. Sign in first with linkly auth login (see Remote Mode).

The bridge cannot connect to a desktop app on another device in your LAN. AI clients on the LAN should connect to the desktop app directly over HTTP (see LAN Access); clients that only support stdio can use linkly mcp --remote instead.

--client <name> names the application in the desktop app’s access log, as in the examples below. With --remote, the name is also sent to the cloud gateway. Configure Claude Desktop and other local AI apps: Add the following to the configuration file of Claude Desktop or similar apps:

macOS
Windows

Edit ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "linkly-ai": {
      "command": "linkly",
      "args": ["mcp", "--client", "claude-desktop"]
    }
  }
}

Edit %APPDATA%\Claude\claude_desktop_config.json:

{
  "mcpServers": {
    "linkly-ai": {
      "command": "linkly",
      "args": ["mcp", "--client", "claude-desktop"]
    }
  }
}

Configure Cursor: In Cursor, open Settings → MCP Servers → Add Server, and add:

Name: linkly-ai
Command: linkly mcp --client cursor

Update CLI

linkly self-update

Automatically checks for and updates to the latest version. The CLI also checks for updates in the background on each launch and will prompt you to run this command if a new version is available.

Connection Modes

The CLI supports three ways to connect to your Linkly AI knowledge base:

Mode	Flags	How it works
Local	(default, no flags needed)	Auto-discovers the desktop app via `~/.linkly/port`
LAN	`--lan`	Direct connection to another device on the local network, using the saved address and token
Remote	`--remote`	Connects via `https://mcp.linkly.ai` cloud tunnel using API Key

Without --lan or --remote, the CLI only connects to the desktop app on this machine.

An API key (starting with lkai_) and a LAN access token work like keys to your local library. Don’t paste them into any AI conversation (ChatGPT, Claude, Cursor, Codex, Doubao, Kimi, and so on), and don’t let an AI assistant run linkly auth set-key for you: conversations are sent to the model provider, kept in the chat history, and in some apps synced to the cloud. To let an AI assistant connect remotely, use the two-step linkly auth login below — you only approve in the browser. Run set-key yourself, in your own terminal. If a key has already appeared in a conversation, revoke it and create a new one in the dashboard; regenerate a LAN token under View MCP connection settings.

Local Mode (default)

No extra flags needed. The CLI reads ~/.linkly/port to find the running desktop app:

linkly search "machine learning"
linkly status

LAN Mode

Connect to a Linkly AI instance running on another device in your local network. Get the address and token from that device: in its desktop app, open the Agent usage page, turn on Allow LAN access under Management, then click View MCP connection settings in the Integration section and copy them from the LAN section (see LAN Access for details). Then save them once on this machine, yourself, in your own terminal:

linkly auth set-key your_lan_token --lan --endpoint http://192.168.1.100:60606

Then use --lan with any command:

linkly search "report" --lan
linkly status --lan

If you’d rather not save them, you can pass the address and token directly each time:

linkly search "report" --endpoint http://192.168.1.100:60606/mcp --token your_lan_token

If the token is regenerated, run auth set-key --lan again with the new token. When you no longer need it, remove the saved LAN config with linkly auth logout --lan.

Saving a LAN connection and the --lan flag require CLI 1.0.0 or later. The CLI can save only one LAN connection; running auth set-key --lan again overwrites the previously saved address and token. To connect to another device temporarily, use --endpoint and --token.

Remote Mode

Connect to your knowledge base from anywhere via the cloud tunnel. First, sign in once:

linkly auth login

The CLI prints a one-time link and a confirmation code (XXXX-XXXX), and opens your browser when it can. Open the link on any device — your phone works fine if the CLI runs on a server — sign in, check that the code matches the one in your terminal, and click Authorize. The CLI then saves a newly issued API key. The link is valid for 10 minutes; the page shows the account you are authorizing, the confirmation code, the device asking for access (as reported by that device), and the permissions it gets. If you don’t want the CLI to try opening a browser, add --no-browser and it only prints the link. Then use --remote with any command:

linkly search "machine learning" --remote
linkly status --remote

Agents and scripts that can’t wait in the foreground split the login in two steps. The agent only hands you the link and the code; the CLI stores the key itself, so it never passes through the conversation. Run both in the same environment, as the same system user, with the same config directory:

linkly auth login --no-wait --json   # {"status":"pending","url":…,"user_code":…,"expires_in":600}
# … pass url and user_code to the user, wait for them to authorize …
linkly auth login --wait --json      # {"status":"ok","account":…,"plan":…,"key_preview":…}

--wait gives up after 300 seconds (change it with --timeout) with the code timeout; run it again while the link is still valid. In --json mode failures carry a code: timeout, expired, denied, no_pending_login, login_in_progress (use --wait, or --restart to start over), already_logged_in (run linkly auth logout first) and network. Every message names the command to run next. Each login creates a new API key named cli-<hostname>-xxxx, which you can see and revoke in the dashboard. An account can hold up to 10 API keys; when you’re at the limit, the authorization page says so. Signing in only proves which account you are — it doesn’t mean your cloud libraries or your desktop app are reachable. Prefer to paste a key? Create one in the dashboard and save it yourself, in your own terminal:

linkly auth set-key lkai_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Check or clear the stored key at any time:

linkly auth status   # which key is in use, whether it's valid, your plan, and the saved LAN config
linkly auth logout   # remove the stored API key (the LAN config is kept); revokes it if auth login issued it

logout also revokes a key that auth login issued — it stops working within about 90 seconds. A key saved with set-key is only removed from this machine, since it may be in use elsewhere; revoke it in the dashboard if needed. Credentials, and a login still waiting for approval, live in ~/.linkly by default. Set LINKLY_CONFIG_DIR to keep them somewhere else — for example one directory per user when an agent serves several people from the same system account. Each directory holds one account. Discovery of the local desktop app (~/.linkly/port) is not affected.

LINKLY_CONFIG_DIR=~/.linkly-alice linkly auth login --no-wait --json
LINKLY_CONFIG_DIR=~/.linkly-alice linkly search "notes" --remote

--lan, --remote and --endpoint cannot be combined. --endpoint and --token are required together, and the saved LAN config is ignored in that case.

Parameter Reference

Global Options

Option	Scope	Description
`--lan`	LAN	Use the LAN config saved by `auth set-key --lan` (conflicts with `--remote`, `--endpoint`)
`--endpoint <URL>`	LAN	Connect to a specific MCP endpoint (e.g. `http://192.168.1.100:60606/mcp`), requires `--token`
`--token <token>`	LAN	Bearer token for LAN authentication (required with `--endpoint`, conflicts with `--remote`)
`--remote`	Remote	Connect via cloud tunnel at `https://mcp.linkly.ai` (conflicts with `--endpoint`)
`--json`	Most commands	Output in JSON format (suitable for scripting and automation). A few commands don’t support it — see the tip below
`--exit-code`	All commands	Distinguish “found nothing” (exit 1) from “failed” (exit 2) — see Exit Codes
`--client <name>`	All commands	Name the calling application, e.g. `--client claude-code`. Agents should always pass it
`-V, --version`	—	Display CLI version number
`-h, --help`	—	Display help information

--lan, --endpoint, --token and --remote are available on the document commands (search, grep, outline, read, list, note-save, find-paths, explore, list-libraries) plus status and doctor. The mcp command only accepts --remote. --json has no effect on auth set-key, self-update, skills install, skills update, completions, or mcp.

Exit Codes

By default the CLI uses the conventional two values: 0 on success, 1 on failure. Note that “success” includes finding nothing — a search with no hits still exits 0. Argument errors (a missing required argument, an invalid value, and so on) always exit 2, with or without --exit-code. Pass --exit-code to tell the two apart:

Code	Meaning
`0`	Ran and produced at least one result
`1`	Ran fine but matched nothing (only `search`, `find-paths`, `grep`, `list`)
`2`	Failed (connection, authentication, bad arguments, errors)

# Only opens the report when the search actually found something
linkly search "quarterly report" --exit-code && open-report

The flag is opt-in because it changes what 1 means. Without it, 1 is “failed” — which is what existing scripts test for.

search Parameters

Parameter	Description	Default
`<QUERY>`	Search keywords or phrase (required)	—
`--limit <N>`	Maximum number of results (1-50)	20
`--type <TYPES>`	Filter by document type (comma-separated): `pdf`, `docx`, `doc`, `pptx`, `xlsx`, `csv`, `epub`, `rtf`, `md`, `txt`, `html`, `image`, `audio`, `video`	All
`--library <NAME>`	Restrict search to a specific library	—
`--path-glob <PATTERN>`	Filter by file path; substring-matched (may appear anywhere, no leading/trailing `*` needed). When the actual path is unknown, run `linkly find-paths` first	—
`--modified-after <ISO>`	Inclusive lower bound on modification time. ISO 8601 UTC: bare date `2024-01-01` or full `2024-01-01T00:00:00Z`	—
`--modified-before <ISO>`	Inclusive upper bound on modification time. Same format as `--modified-after`	—
`--time-sort <MODE>`	Time-based reordering: `newest` / `oldest`. Omit to keep relevance ordering	—
`--scope <SCOPE>`	`folder` searches all indexed content; `notes` restricts results to your notes and ignores `--library` / `--path-glob`	folder
`--tags <LIST>`	Comma-separated note tags; returns only documents carrying all of them	—

find-paths Parameters

Parameter	Description	Default
`--patterns <LIST>`	Comma-separated keyword list (required). Multiple keywords are OR-matched; pass several variants in one call (translation pairs, casing). Case-insensitive for ASCII; CJK is literal.	—
`--library <NAME>`	Restrict to a specific library	—
`--limit <N>`	Maximum number of candidate folders (1-50)	10

outline Parameters

Parameter	Description	Default
`<ID>...`	Document IDs (required, supports multiple). Pass `-` to read the IDs from stdin, one per line	—
`--expand <IDS>`	Outline node IDs to expand, comma-separated (e.g. `2,3.1`); all other nodes stay collapsed	Auto

grep Parameters

Parameter	Description	Default
`<PATTERN>`	Regular expression pattern (required)	—
`<DOC_ID>...`	Document IDs to search (required, supports multiple). Pass `-` to read the IDs from stdin	—
`-C, --context`	Lines of context before and after	3
`-B, --before`	Lines of context before each match	—
`-A, --after`	Lines of context after each match	—
`-i`	Case-insensitive matching	—
`--mode`	Output mode: `content` or `count`	content
`--limit`	Maximum matches (max 100)	20
`--offset`	Number of matches to skip	0
`--fuzzy-whitespace`	Fuzzy whitespace matching: `true` to force on, `false` to force off, omit for auto (PDF on, others off)	auto

read Parameters

Parameter	Description	Default
`<ID>...`	Document IDs (required, supports multiple). Pass `-` to read the IDs from stdin	—
`--offset <N>`	Starting line number (from 1)	1
`--limit <N>`	Number of lines to read (max 500)	200
`--image-text <DETAIL>`	Detail for images referenced in the page: `none` (mapping only), `abstract` (excerpt), `full` (inline OCR text)	abstract

list Parameters

Parameter	Description	Default
`--scope <SCOPE>`	Container to list: `folder` (indexed files under a directory), `library` (one library’s files), or `notes` (required)	—
`--library <LIB>`	Which library, for `--scope library` — a name, `local://<id>`, or `cloud://<owner>/<slug>` (remote)	—
`--path <DIR>`	Directory to list — an absolute path locally, a relative prefix for cloud libraries	—
`--type <LIST>`	Comma-separated document types (`folder` / `library` only), e.g. `pdf,docx`	all
`--modified-after <DATE>`	Only items modified on or after this date (`folder` / `library` only). ISO 8601, e.g. `2026-01-01`	—
`--modified-before <DATE>`	Only items modified on or before this date. Same format	—
`--tags <LIST>`	Comma-separated tags (`notes` only); returns only items carrying all of them	—
`--limit <N>`	Maximum items (max 200; capped at 50 while snippets are on)	50
`--offset <N>`	Pagination offset	0
`--sort <ORDER>`	`recent` (newest first), `oldest`, or `name`	recent
`--snippet` / `--no-snippet`	Force per-item snippets on / off (mutually exclusive). Snippets default on for `notes`, off for `folder` / `library`	per scope

note-save Parameters

Parameter	Description	Default
`--mode <MODE>`	`create` writes a new note; `edit` rewrites one (requires `--note-id` and `--base-version`)	—
`--content <TEXT>`	Note body (required). Pass `-` to read it from stdin	—
`--note-id <UUID>`	Which note to edit, from `linkly list --scope notes`	—
`--base-version <HASH>`	The note’s current version, from `linkly list --scope notes`. Rejects the write if the note changed meanwhile	—
`--tags <LIST>`	Comma-separated tags to add — remove a tag by deleting its `#tag` marker from the content	—
`--app-name <NAME>`	Display name of the application hosting the conversation, shown as the note’s source badge. Max 64 characters	—

completions Parameters

Parameter	Description	Default
`<SHELL>`	`bash`, `zsh`, `fish`, `powershell` or `elvish` (required)	—

Getting Started

Core Features

Connect Your AI Tools

For AI Agents

Using Linkly AI CLI

Introduction to Linkly AI CLI

Terminal Search

MCP Bridge

Installation

Usage

Check Connection Status

Search Documents

View Document Outline

Search Patterns in Documents

Read Document Content

Find Paths (find-paths)

Libraries and Overview (list-libraries, explore)

Notes

Diagnose Connections (doctor)

Manage Skills (skills)

Shell Completions

MCP Mode

Update CLI

Connection Modes

Local Mode (default)

LAN Mode

Remote Mode

Parameter Reference

Global Options

Exit Codes

search Parameters

find-paths Parameters

outline Parameters

grep Parameters

read Parameters

list Parameters

note-save Parameters

completions Parameters

​Introduction to Linkly AI CLI

Terminal Search

MCP Bridge

​Installation

​Usage

​Check Connection Status

​Search Documents

​View Document Outline

​Search Patterns in Documents

​Read Document Content

​Find Paths (find-paths)

​Libraries and Overview (list-libraries, explore)

​Notes

​Diagnose Connections (doctor)

​Manage Skills (skills)

​Shell Completions

​MCP Mode

​Update CLI

​Connection Modes

​Local Mode (default)

​LAN Mode

​Remote Mode

​Parameter Reference

​Global Options

​Exit Codes

​search Parameters

​find-paths Parameters

​outline Parameters

​grep Parameters

​read Parameters

​list Parameters

​note-save Parameters

​completions Parameters

Introduction to Linkly AI CLI

Installation

Usage

Check Connection Status

Search Documents

View Document Outline

Search Patterns in Documents

Read Document Content

Find Paths (find-paths)

Libraries and Overview (list-libraries, explore)

Notes

Diagnose Connections (doctor)

Manage Skills (skills)

Shell Completions

MCP Mode

Update CLI

Connection Modes

Local Mode (default)

LAN Mode

Remote Mode

Parameter Reference

Global Options

Exit Codes

search Parameters

find-paths Parameters

outline Parameters

grep Parameters

read Parameters

list Parameters

note-save Parameters

completions Parameters