Skip to content
Back to search

mcp-logseq

MCP server to interact with LogSeq via its Local HTTP API - enabling AI assistants like Claude to seamlessly read, write, and manage your LogSeq graph.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/ergut--mcp-logseq/badge.svg)](/listings/ergut--mcp-logseq)

HTML

<a href="/listings/ergut--mcp-logseq"><img src="/api/listings/ergut--mcp-logseq/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Step 1: Enable LogSeq API

1. **Settings** → **Features** → Check "Enable HTTP APIs server" 2. Click the **API button (🔌)** in LogSeq → **"Start server"** 3. **Generate API token**: API panel → "Authorization tokens" → Create new

Step 2: Add to your MCP client (No Installation Required!)

Claude Code

claude mcp add mcp-logseq \
  --env LOGSEQ_API_TOKEN=your_token_here \
  --env LOGSEQ_API_URL=http://localhost:12315 \
  -- uv run --with mcp-logseq mcp-logseq

Claude Desktop

Add to your config file (`Settings → Developer → Edit Config`):

{
  "mcpServers": {
    "mcp-logseq": {
      "command": "uv",
      "args": ["run", "--with", "mcp-logseq", "mcp-logseq"],
      "env": {
        "LOGSEQ_API_TOKEN": "your_token_here",
        "LOGSEQ_API_URL": "http://localhost:12315"
      }
    }
  }
}

Codex CLI

With [uv](https://docs.astral.sh/uv/getting-started/installation/) installed and Logseq's HTTP API running (Step 1), add this to `~/.codex/config.toml`:

[mcp_servers.logseq]
command = "uv"
args = ["run", "--with", "mcp-logseq", "mcp-logseq"]

[mcp_servers.logseq.env]
LOGSEQ_API_TOKEN = "YOUR_LOGSEQ_TOKEN"
LOGSEQ_API_URL = "http://127.0.0.1:12315"

Replace `YOUR_LOGSEQ_TOKEN` with your Logseq token. If Codex cannot find `uv`, run `which uv` in Terminal and use the full path for `command`. Keep your token private.

Use the API base address above, **without `/mcp`**. Codex runs this adapter through STDIO; the adapter connects to Logseq's regular HTTP API.

Restart Codex, open a new local task, and ask:

> Use Logseq to list my journal pages, then read today's journal. Do not change anything.

Keep Logseq and its API server running. Codex starts the adapter automatically—no tunnel or separate Terminal window is needed.

*Tested with a Logseq DB graph for page listing and journal retrieval. This setup is for local Codex tasks, not cloud-hosted ChatGPT Chat.*

OpenCode

Add to `~/.config/opencode/opencode.json`:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "mcp-logseq": {
      "type": "local",
      "command": ["uv", "run", "--with", "mcp-logseq", "mcp-logseq"],
      "enabled": true,
      "environment": {
        "LOGSEQ_API_URL": "http://localhost:12315",
        "LOGSEQ_API_TOKEN": "your_token_here"
      }
    }
  }
}

Step 3: Start Using!

"Please help me organize my LogSeq notes. Show me what pages I have."

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 444 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <div align="center">
  2. <img src="assets/images/logo.png" alt="MCP LogSeq" width="200" height="200">
  3. <h1>MCP server for LogSeq</h1>
  4. <p>Connect Claude to your LogSeq knowledge base. Read, create, and manage pages — with optional semantic vector search and DB-mode graph support.</p>
  5. </div>
  6. ## ✨ What You Can Do
  7. Transform your LogSeq knowledge base into an AI-powered workspace! This MCP server enables Claude to seamlessly interact with your LogSeq graphs.
  8. ### 🎯 Real-World Examples
  9. **📊 Intelligent Knowledge Management**
  10. ```
  11. "Analyze all my project notes from the past month and create a status summary"
  12. "Find pages mentioning 'machine learning' and create a study roadmap"
  13. "Search for incomplete tasks across all my pages"
  14. ```
  15. **📝 Automated Content Creation**
  16. ```
  17. "Create a new page called 'Today's Standup' with my meeting notes"
  18. "Add today's progress update to my existing project timeline page"
  19. "Create a weekly review page from my recent notes"
  20. ```
  21. **🔍 Smart Research & Analysis**
  22. ```
  23. "Compare my notes on React vs Vue and highlight key differences"
  24. "Find all references to 'customer feedback' and summarize themes"
  25. "Create a knowledge map connecting related topics across pages"
  26. ```
  27. **🧠 Semantic Search** *(optional, requires vector setup)*
  28. ```
  29. "Find everything I wrote about burnout, even if I didn't use that word"
  30. "What notes relate to my thoughts on deep work?"
  31. "Search across my Dutch and English notes for ideas about productivity"
  32. ```
  33. **🤝 Meeting & Documentation Workflow**
  34. ```
  35. "Read my meeting notes and create individual task pages for each action item"
  36. "Get my journal entries from this week and create a summary page"
  37. "Search for 'Q4 planning' and organize all related content into a new overview page"
  38. ```
  39. ### 💡 Key Benefits
  40. - **Zero Context Switching**: Claude works directly with your LogSeq data
  41. - **Preserve Your Workflow**: No need to export or copy content manually
  42. - **Intelligent Organization**: AI-powered page creation, linking, and search
  43. - **Enhanced Productivity**: Automate repetitive knowledge work
  44. - **Semantic Vector Search** *(optional)*: Find notes by meaning using local Ollama or hosted OpenAI-compatible embeddings
  45. - **DB-mode Support** *(opt-in)*: Read and write class properties on Logseq DB-mode graphs
  46. ---
  47. ## 🚀 Quick Start
  48. ### Step 1: Enable LogSeq API
  49. 1. **Settings** → **Features** → Check "Enable HTTP APIs server"
  50. 2. Click the **API button (🔌)** in LogSeq → **"Start server"**
  51. 3. **Generate API token**: API panel → "Authorization tokens" → Create new
  52. ### Step 2: Add to your MCP client (No Installation Required!)
  53. #### Claude Code
  54. ```bash
  55. claude mcp add mcp-logseq \
  56. --env LOGSEQ_API_TOKEN=your_token_here \
  57. --env LOGSEQ_API_URL=http://localhost:12315 \
  58. -- uv run --with mcp-logseq mcp-logseq
  59. ```
  60. #### Claude Desktop
  61. Add to your config file (`Settings → Developer → Edit Config`):
  62. ```json
  63. {
  64. "mcpServers": {
  65. "mcp-logseq": {
  66. "command": "uv",
  67. "args": ["run", "--with", "mcp-logseq", "mcp-logseq"],
  68. "env": {
  69. "LOGSEQ_API_TOKEN": "your_token_here",
  70. "LOGSEQ_API_URL": "http://localhost:12315"
  71. }
  72. }
  73. }
  74. }
  75. ```
  76. #### Codex CLI
  77. With [uv](https://docs.astral.sh/uv/getting-started/installation/) installed and Logseq's HTTP API running (Step 1), add this to `~/.codex/config.toml`:
  78. ```toml
  79. [mcp_servers.logseq]
  80. command = "uv"
  81. args = ["run", "--with", "mcp-logseq", "mcp-logseq"]
  82. [mcp_servers.logseq.env]
  83. LOGSEQ_API_TOKEN = "YOUR_LOGSEQ_TOKEN"
  84. LOGSEQ_API_URL = "http://127.0.0.1:12315"
  85. ```
  86. Replace `YOUR_LOGSEQ_TOKEN` with your Logseq token. If Codex cannot find `uv`, run `which uv` in Terminal and use the full path for `command`. Keep your token private.
  87. Use the API base address above, **without `/mcp`**. Codex runs this adapter through STDIO; the adapter connects to Logseq's regular HTTP API.
  88. Restart Codex, open a new local task, and ask:
  89. > Use Logseq to list my journal pages, then read today's journal. Do not change anything.
  90. Keep Logseq and its API server running. Codex starts the adapter automatically—no tunnel or separate Terminal window is needed.
  91. *Tested with a Logseq DB graph for page listing and journal retrieval. This setup is for local Codex tasks, not cloud-hosted ChatGPT Chat.*
  92. #### OpenCode
  93. Add to `~/.config/opencode/opencode.json`:
  94. ```json
  95. {
  96. "$schema": "https://opencode.ai/config.json",
  97. "mcp": {
  98. "mcp-logseq": {
  99. "type": "local",
  100. "command": ["uv", "run", "--with", "mcp-logseq", "mcp-logseq"],
  101. "enabled": true,
  102. "environment": {
  103. "LOGSEQ_API_URL": "http://localhost:12315",
  104. "LOGSEQ_API_TOKEN": "your_token_here"
  105. }
  106. }
  107. }
  108. }
  109. ```
  110. ### Step 3: Start Using!
  111. ```
  112. "Please help me organize my LogSeq notes. Show me what pages I have."
  113. ```
  114. ---
  115. ## 🔬 Vector Search (Optional)
  116. Semantic search over your Logseq graph using configurable embeddings — find notes by meaning, not just keywords. Searches across all your pages using vector similarity and full-text search combined, with cross-language support.
  117. Use [Ollama](https://ollama.com) for fully local embeddings, OpenAI, or another OpenAI-compatible embeddings endpoint. [LanceDB](https://lancedb.com) remains local in every configuration. Hosted providers receive the note text being embedded.
  118. → **[Full setup guide: VECTOR_SEARCH.md](VECTOR_SEARCH.md)**
  119. ---
  120. ## 🛠️ Available Tools
  121. The server provides 17 tools with intelligent markdown parsing, plus 3 optional vector search tools:
  122. | Tool | Purpose | Example Use |
  123. |------|---------|-------------|
  124. | **`list_pages`** | Browse your graph; `sort: "updated"` / `updated_since` find recently modified pages | "Which pages did I change this week?" |
  125. | **`get_page_content`** | Read page content | "Get my project notes" |
  126. | **`create_page`** | Add new pages with structured blocks | "Create a meeting notes page with agenda items" |
  127. | **`update_page`** | Modify pages (append/replace modes) | "Update my task list" |
  128. | **`delete_page`** | Remove pages | "Delete the old draft page" |
  129. | **`delete_block`** | Remove a block by UUID | "Delete this specific block" |
  130. | **`update_block`** | Edit block content by UUID | "Update this specific block text" |
  131. | **`get_block`** | Read a block by UUID with its properties and children | "Show me this specific block" |
  132. | **`search`** | Find content across graph | "Search for 'productivity tips'" |
  133. | **`query`** | Execute Logseq DSL queries (raw datalog not supported) | "Find all TODO tasks tagged #project" |
  134. | **`find_pages_by_property`** | Search pages by property | "Find all pages with status = active" |
  135. | **`get_pages_from_namespace`** | List pages in a namespace | "Show all pages under Customer/" |
  136. | **`get_pages_tree_from_namespace`** | Hierarchical namespace view | "Show Projects/ as a tree" |
  137. | **`rename_page`** | Rename with reference updates | "Rename 'Old Name' to 'New Name'" |
  138. | **`get_page_backlinks`** | Find pages linking to a page | "What links to this page?" |
  139. | **`insert_nested_block`** | Insert child/sibling blocks | "Add a child block under this task" |
  140. | **`set_block_properties`** | Set DB-mode class properties on a block | "Set the status of this block to active" *(DB-mode only)* |
  141. | **`vector_search`** ⚗️ | Semantic search by meaning | "Find notes about shadow work or Jung" |
  142. | **`sync_vector_db`** ⚗️ | Sync vector DB with graph files | "Update the search index" |
  143. | **`vector_db_status`** ⚗️ | Show vector DB health and staleness | "Is my search index up to date?" |
  144. ⚗️ *Requires vector search setup — see [VECTOR_SEARCH.md](VECTOR_SEARCH.md)*
  145. ### 🎨 Smart Markdown Parsing (v1.1.0+)
  146. The `create_page` and `update_page` tools now automatically convert markdown into Logseq's native block structure:
  147. **Markdown Input:**
  148. ````markdown
  149. ---
  150. tags: [project, active]
  151. priority: high
  152. ---
  153. # Project Overview
  154. Introduction paragraph here.
  155. ## Tasks
  156. - Task 1
  157. - Subtask A
  158. - Subtask B
  159. - Task 2
  160. ## Code Example
  161. ```python
  162. def hello():
  163. print("Hello Logseq!")
  164. ```
  165. ````
  166. **Result:** Creates properly nested blocks with:
  167. - ✅ Page properties from YAML frontmatter (`tags`, `priority`)
  168. - ✅ Hierarchical sections from headings (`#`, `##`, `###`)
  169. - ✅ Nested bullet lists with proper indentation
  170. - ✅ Code blocks preserved as single blocks
  171. - ✅ Checkbox support (`- [ ]` → TODO, `- [x]` → DONE)
  172. **Update Modes:**
  173. - **`append`** (default): Add new content after existing blocks
  174. - **`replace`**: Clear page and replace with new content
  175. ### 🔁 Safe Retries & Large Writes
  176. `create_page` fails with a clear error if a page with the same title already exists, instead of letting Logseq silently create numbered duplicates (`Page(1)`, `Page 2`, ...). This makes retries after a timeout safe: if a previous `create_page` call timed out but actually committed, the retry tells you the page exists rather than fragmenting your content across ghost pages.
  177. For large writes, prefer this pattern over one giant `create_page` call:
  178. 1. Create the page with little or no content (`create_page` with just the title and properties)
  179. 2. Append content in smaller chunks with `update_page` (`mode: append`)
  180. 3. Read back with `get_page_content` to verify the result
  181. If you hit the "already exists" error mid-ingest, use `get_page_content` to see what landed, then continue with `update_page` instead of re-creating.
  182. ---
  183. ## ⚙️ Prerequisites
  184. ### LogSeq Setup
  185. - **LogSeq installed** and running
  186. - **HTTP APIs server enabled** (Settings → Features)
  187. - **API server started** (🔌 button → "Start server")
  188. - **API token generated** (API panel → Authorization tokens)
  189. ### System Requirements
  190. - **[uv](https://docs.astral.sh/uv/)** Python package manager
  191. - **MCP-compatible client** (Claude Code, Claude Desktop, etc.)
  192. ---
  193. ## 🔧 Configuration
  194. ### Environment Variables
  195. - **`LOGSEQ_API_TOKEN`** (required): Your LogSeq API token
  196. - **`LOGSEQ_API_URL`** (optional): Server URL (default: `http://localhost:12315`)
  197. - **`LOGSEQ_VERIFY_SSL`** (optional): Whether to verify the TLS certificate of an `https://` `LOGSEQ_API_URL`. Defaults to verifying when the URL is `https://`; set to `0`, `false`, or `no` to skip verification for self-signed certificates. Any other value enables verification.
  198. - **`LOGSEQ_API_CONNECT_TIMEOUT`** (optional): HTTP connect timeout in seconds (default: `3`)
  199. - **`LOGSEQ_API_READ_TIMEOUT`** (optional): HTTP read timeout in seconds (default: `6`)
  200. - **`LOGSEQ_LOG_LEVEL`** (optional): Log verbosity — `DEBUG`, `INFO`, `WARNING`, `ERROR`, or `CRITICAL` (default: `INFO`). Logs go to stderr. At `DEBUG`, the MCP SDK's own logger stays capped at `INFO` so full request payloads are not logged.
  201. - **`LOGSEQ_LOG_FILE`** (optional): Path to a log file. When unset (the default), nothing is written to disk. Tool calls are logged with argument names and result sizes only, so page/block content does not appear in routine logs.
  202. - **`LOGSEQ_DB_MODE`** (optional): Set to `true` to enable DB-mode property support. Only for Logseq DB-mode graphs (beta). Markdown/file-based graph users should leave this unset.
  203. - **`LOGSEQ_EXCLUDE_TAGS`** (optional): Comma-separated tags — pages with these tags are hidden from all tools. See [Privacy & Access Control](#-privacy--access-control) below.
  204. - **`LOGSEQ_INCLUDE_NAMESPACES`** (optional): Comma-separated namespace allow-list (e.g. `work,projects`). When set, **only** pages in these namespaces and their sub-pages are accessible — everything else, including top-level pages without a namespace, is hidden from listings/search and denied on direct access. See [Privacy & Access Control](#-privacy--access-control) below.
  205. - **`LOGSEQ_EXCLUDE_NAMESPACES`** (optional): Comma-separated namespace deny-list (e.g. `finance,work/secret`). These namespaces are always blocked, taking priority over the include list. See [Privacy & Access Control](#-privacy--access-control) below.
  206. - **`LOGSEQ_WRITE_NAMESPACES`** (optional): Comma-separated write allow-list (e.g. `Beren`). When set, write tools may only target pages in these namespaces; everything else that is readable stays read-only. Applied on top of the include/exclude rules, never instead of them. See [Privacy & Access Control](#-privacy--access-control) below.
  207. - **`LOGSEQ_CONFIG_FILE`** (optional): Path to a shared JSON config file holding the graph path, ACL defaults, and the `vector` block. Env vars (`LOGSEQ_EXCLUDE_TAGS`, `LOGSEQ_INCLUDE_NAMESPACES`, `LOGSEQ_EXCLUDE_NAMESPACES`, `LOGSEQ_WRITE_NAMESPACES`) override the matching keys in this file.
  208. - **`MCP_HTTP_AUTH_TOKEN`** (required for `--transport http`): Bearer token clients must send as `Authorization: Bearer <token>`. The server refuses to start in HTTP mode without it. See [Serving over HTTP](docs/SERVING.md).
  209. ### Privacy & Access Control
  210. Pages tagged with excluded tags are completely hidden from AI — they won't appear in listings, searches, or queries, and attempting to read them directly returns an access-denied error.
  211. **Quick setup via env var:**
  212. ```bash
  213. LOGSEQ_EXCLUDE_TAGS=private,secret
  214. ```
  215. **Via config file** (also used for [vector search](VECTOR_SEARCH.md)):
  216. ```json
  217. {
  218. "logseq_graph_path": "/path/to/your/logseq/pages",
  219. "exclude_tags": ["private", "secret"]
  220. }
  221. ```
  222. Point to it with `LOGSEQ_CONFIG_FILE=/path/to/config.json`.
  223. In your Logseq pages, tag any page you want to protect:
  224. ```
  225. tags:: private
  226. ```
  227. The exclusion applies to all tools: `list_pages`, `get_page_content`, `search`, `query`, and the optional vector search. If you also use vector search, `exclude_tags` at the root is automatically merged into the vector index exclusion list — private pages are never embedded.
  228. #### Namespace access control
  229. You can restrict access to specific namespaces using `LOGSEQ_INCLUDE_NAMESPACES` and `LOGSEQ_EXCLUDE_NAMESPACES`.
  230. **Include list (strict allow-list):** Only the listed namespaces and their sub-pages are visible; everything else is hidden.
  231. ```bash
  232. LOGSEQ_INCLUDE_NAMESPACES=work,projects
  233. ```
  234. **Exclude list (deny-list):** The listed namespaces are always blocked, even if they appear in the include list.
  235. ```bash
  236. LOGSEQ_EXCLUDE_NAMESPACES=work/secret,finance
  237. ```
  238. **Via config file:**
  239. ```json
  240. {
  241. "include_namespaces": ["work", "projects"],
  242. "exclude_namespaces": ["work/secret", "finance"],
  243. "write_namespaces": ["work/drafts"]
  244. }
  245. ```
  246. **Write list (write allow-list):** Everything the read rules allow stays readable, but write tools (`create_page`, `update_page`, `delete_page`, `rename_page`, `update_block`, `delete_block`, `insert_nested_block`, `set_block_properties`) may only target pages in these namespaces. Useful when an assistant should read a wider area than it may edit:
  247. ```bash
  248. LOGSEQ_INCLUDE_NAMESPACES=Family,Beren
  249. LOGSEQ_WRITE_NAMESPACES=Beren # reads Family/* and Beren/*, writes only Beren/*
  250. ```
  251. `rename_page` needs both the old and the new name inside the write list; block tools are checked against the block's owning page (denied if it cannot be resolved). A write outside the list returns "page 'X' is read-only for this assistant". The write list never widens read access: a write namespace not covered by the include list is still denied (a warning is logged at startup). Unset means no extra restriction. Every allowed write is logged at INFO as `Write: tool=<name> page=<page name>` (names only, never content).
  252. Matching is segment-based and case-insensitive: `work` matches `work` and `work/projects` but not `workshop`. The behavior mirrors `LOGSEQ_EXCLUDE_TAGS`: list/search results silently omit blocked pages; direct read, write, delete, and block operations return an access-denied error.
  253. Access control is enforced at the **page** level and applied across every tool: list/search/query results omit blocked pages, direct page/block access and backlinks are denied, and vector search is filtered. Block-level results from `search` and `query` are resolved back to their owning page, so a block belonging to a restricted page is filtered out of those results too.
  254. **Index-time namespace scoping (vector DB only).** The keys above are *query-time*: every page is embedded, and blocked ones are filtered out of each response. For the vector DB you can also scope at *index time* — decide which namespaces are embedded into the DB **at all** — with `include_namespaces` / `exclude_namespaces` inside the `vector` block of the config file:
  255. ```json
  256. {
  257. "vector": {
  258. "enabled": true,
  259. "include_namespaces": ["work"],
  260. "exclude_namespaces": ["work/secret"]
  261. }
  262. }
  263. ```
  264. This is global (it shapes the shared DB for every consumer), and it keeps unwanted content off disk entirely rather than filtering it on read — useful for secrets you never want embedded, or to keep the index small when everyone only cares about a subset. Matching is the same segment-based, case-insensitive rule. Because it changes what the index contains, it only takes effect after a full re-index: `logseq-sync --rebuild`.
  265. ### 🌐 Serving over HTTP, multi-profile & TLS
  266. By default the server speaks **stdio** — your client spawns it as a subprocess, and most users need nothing more. To serve **sandboxed or remote clients** over the network, `mcp-logseq` can run as a long-lived HTTP service with bearer auth, per-profile isolation, and TLS:
  267. ```bash
  268. mcp-logseq --transport http --host 127.0.0.1 --port 12320 # requires MCP_HTTP_AUTH_TOKEN
  269. ```
  270. The full deployment guide — the server-side **security model**, the **per-profile multi-instance** pattern, the separate **`logseq-sync` writer**, and native **TLS** / reverse-proxy setup — lives in **[docs/SERVING.md](docs/SERVING.md)**. Non-loopback binds over plain HTTP are refused unless you supply TLS or pass `--insecure`.
  271. ### Alternative Setup Methods
  272. #### Using .env file
  273. ```bash
  274. # .env
  275. LOGSEQ_API_TOKEN=your_token_here
  276. LOGSEQ_API_URL=http://localhost:12315
  277. ```
  278. #### System environment variables
  279. ```bash
  280. export LOGSEQ_API_TOKEN=your_token_here
  281. export LOGSEQ_API_URL=http://localhost:12315
  282. ```
  283. ---
  284. ## 🔍 Verification & Testing
  285. ### Test LogSeq Connection
  286. ```bash
  287. uv run --with mcp-logseq python -c "
  288. from mcp_logseq.logseq import LogSeq
  289. api = LogSeq(api_key='your_token')
  290. print(f'Connected! Found {len(api.list_pages())} pages')
  291. "
  292. ```
  293. ### Verify MCP Registration
  294. ```bash
  295. claude mcp list # Should show mcp-logseq
  296. ```
  297. ### Debug with MCP Inspector
  298. ```bash
  299. npx @modelcontextprotocol/inspector uv run --with mcp-logseq mcp-logseq
  300. ```
  301. ---
  302. ## 🐛 Troubleshooting
  303. ### Common Issues
  304. #### "LOGSEQ_API_TOKEN environment variable required"
  305. - ✅ Enable HTTP APIs in **Settings → Features**
  306. - ✅ Click **🔌 button** → **"Start server"** in LogSeq
  307. - ✅ Generate token in **API panel → Authorization tokens**
  308. - ✅ Verify token in your configuration
  309. #### "spawn uv ENOENT" (Claude Desktop)
  310. Claude Desktop can't find `uv`. Use the full path:
  311. ```bash
  312. which uv # Find your uv location
  313. ```
  314. Update config with full path:
  315. ```json
  316. {
  317. "mcpServers": {
  318. "mcp-logseq": {
  319. "command": "/Users/username/.local/bin/uv",
  320. "args": ["run", "--with", "mcp-logseq", "mcp-logseq"],
  321. "env": { "LOGSEQ_API_TOKEN": "your_token_here" }
  322. }
  323. }
  324. }
  325. ```
  326. **Common uv locations:**
  327. - Curl install: `~/.local/bin/uv`
  328. - Homebrew: `/opt/homebrew/bin/uv`
  329. - Pip install: Check with `which uv`
  330. #### Connection Issues
  331. - ✅ Confirm LogSeq is running
  332. - ✅ Verify API server is **started** (not just enabled)
  333. - ✅ Check port 12315 is accessible
  334. - ✅ Test with verification command above
  335. ---
  336. ## 👩‍💻 Development
  337. For local development, testing, and contributing, see **[DEVELOPMENT.md](DEVELOPMENT.md)**.
  338. ---
  339. <div align="center">
  340. <p><strong>Ready to supercharge your LogSeq workflow with AI?</strong></p>
  341. <p>⭐ <strong>Star this repo</strong> if you find it helpful!</p>
  342. </div>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.