Connect your AI assistant to ScholarThread (MCP)

If you already draft notes with an AI assistant — Claude Code, Claude Desktop, or anything else that speaks MCP (the Model Context Protocol) — you can point it directly at your ScholarThread library. It searches your papers, drafts and updates concept notes, records claims, and links evidence, using the same rules the web app enforces.

Connecting an assistant over MCP is a Pro feature: on a Free plan, Settings → API keys shows an Upgrade to Pro button instead of the key form.

This is not a chatbot bolted onto ScholarThread. It is your own assistant, running wherever you already run it, given a scoped key to your library.

Step 1 — Create an API key

You need a Pro plan for this step. Open Settings → API keys, and under Create a key:

• Name it something that tells you where it's used later — "Claude Code — laptop" is more useful in six months than "key 1".
• Scope: choose Read if you only want the assistant to search and browse, or Read + write if you want it to create and update concepts, record claims, and link evidence. Read + write also covers triggering evidence extraction, which calls out to a model on ScholarThread's side — a metered operation, not a plain database write.

Expand

Then choose Create key. The key is shown to you exactly once, right after creation, with the note "copy it now. It won't be shown again." Use the copy button, then choose Done — ScholarThread does not store the plaintext and cannot show it to you again. If you lose it, revoke it and create a new one.

Expand

Treat the key like a password. Anyone holding it can act as you, within its scope, for as long as it's active. Revoke a key the moment you stop using it: in the Your keys table, choose Revoke next to it and confirm with Yes, revoke. It takes effect immediately, and anything still using the key stops working.

Expand

Step 2 — Connect your assistant

For Claude Code, add the server from a terminal:

claude mcp add --transport http scholarthread \
  https://api.scholarthread.com/mcp \
  --header "Authorization: Bearer stk_your_key_here" \
  --scope user

--scope user makes the connection available everywhere you run Claude Code, not just one project directory — useful since your notes and papers aren't tied to any single codebase. Run claude mcp list to confirm it connected.

For Claude Desktop or another MCP client, the shape is the same: a Streamable HTTP server at that same URL, authenticated with an Authorization: Bearer header carrying your key. Check your client's own docs for exactly where to paste the URL and header.

What the assistant can actually do

Once connected, the assistant has tools to:

• Search your library — papers and the passages inside them — and look up a specific paper.
• List and read concept notes, including the standard template (Definition / Why it matters / Open questions / Related concepts).
• Validate a draft concept body against that template before writing it.
• Create and update concepts, record claims on them, and link a claim's evidence to a paper, passage, another note, or another claim — with a read + write key.
• Trigger evidence extraction for a concept against papers already in your library — a longer-running, model-backed job, also read + write only.

There's also a short resource the assistant can read on its own — scholarthread://import-guide — covering a few things worth knowing up front:

• A paper has to be in your library before a claim can cite it. With a read + write key the assistant can add a paper from metadata you give it (title, authors, year, DOI), but it can't upload a PDF or import from Zotero. If your assistant is walking through a folder of notes that cite sources you haven't imported yet, expect claims without linked evidence until you import those papers (Zotero sync or the web app).
• [[Title]] in a note body really does create a link — writing a wikilink into a concept section, where another concept already exists under that exact title, resolves into a real link between them, the same as typing it in the ScholarThread editor.
• The four-section template is the target shape. If your own notes carry more structure — a "tensions with other work" section, source annotations — the assistant folds it into the closest existing section ("Why it matters" or "Open questions") by default, and adds a new heading only when the material fits nowhere else.

A realistic first session

A good way to get a feel for it: point your assistant at a folder of existing notes — an Obsidian vault, a set of literature notes, whatever you already have — and ask it to draft one or two as ScholarThread concepts first, before turning it loose on the whole folder. Check what it produces against your own notes, adjust how you're prompting it, and only then let it work through more.

Scope and safety, briefly

• A key only ever acts within your own tenant — it cannot see or touch anyone else's library, notes, or papers.
• Read-scoped keys cannot write anything, even if the assistant tries.
• Every write still goes through the same validation the web app uses — a malformed concept body is rejected the same way whether it came from your keyboard or your assistant.

If anything looks off — a link that shouldn't exist, a claim you didn't expect — the fix is the same as anywhere else in ScholarThread: edit or delete it directly in the app. The assistant has no more authority over your library than the scope of the key you gave it.