Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Meet Rupert MCP Server ask the AI how to set up a new hire"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
An MCP server that lets Claude work with the Meet Rupert knowledgebase (https://app.meetrupert.com): search and read documentation, ask the RAG AI questions (one-shot or in a conversation), and create/edit documents.
Node 20+ / TypeScript ESM, the official @modelcontextprotocol/sdk over stdio,
built with tsup.
Tool | Description |
| Search documents by title; returns ids, titles, status, categories (paginated). |
| Read a document by id; body returned as Markdown. |
| Create a document from Markdown. Defaults to draft (not AI-searchable) unless |
| Edit a document; omitted fields are preserved. |
| List categories with ids and document counts (for tagging / retrieval scoping). |
| Upload an image from a file path or HTTPS URL (never base64) and get a |
| List a document's images with their ids and whether they still resolve in storage. |
| Write an image to a path, or return a short-lived signed URL. Reports size + sha256. |
| Remove an image's reference from a document. Does not delete the stored file — see Attachments. |
| Ask a one-shot natural-language question; returns an answer + source documents. |
| Start a multi-turn conversation thread; returns a |
| Ask a question within a thread (remembers prior context). |
| List recent conversation threads to resume. |
Related MCP server: BookStack MCP Server
Meet Rupert has no API-key / service-token auth, so this server logs in as a
real user via POST /api/login/local, caches the short-lived JWT access token,
and silently re-authenticates when it nears expiry or on a 401. All requests
are scoped to the user's organisation, which is auto-resolved from the login
response (override with MEETRUPERT_ORG_ID).
The two "ask" tools consume the platform's text/event-stream RAG endpoints and
return the fully-accumulated answer plus its sources. Document content is
stored as Tiptap JSON and transparently converted to/from Markdown so Claude can
read and author documents in plain text.
Images use the platform's existing presigned-upload flow: the server asks for a
presigned PUT, uploads the bytes itself, and stores the returned storage key in
a Tiptap image node — the same representation the web editor produces. Reading
an image back goes through a short-lived media token. See
Attachments.
Tip: Create a dedicated low-privilege service user (role
editor) in Meet Rupert for this server rather than using a personal admin login.
Documents can embed images. The workflow is two calls:
create_attachment { path: "C:/Users/you/Pictures/step4-poll-fileset-500.png" }
→ { attachmentId: "9f3c1a2e-….png",
contentLength: 92324,
sha256: "…",
markdownRef: "" }
create_document { title: "New Defect Form",
content: "# Steps\n\n" }create_document and update_document resolve every attachment://<id> to its
storage key at save time. read_document renders stored images back as
attachment:// refs, so a document can be read, edited and written back without
losing them.
The caller never supplies image bytes — it names a source and the server reads it. This is not a stylistic choice. A model cannot reliably reproduce a large base64 payload into a tool-call argument: in testing an 18,880-byte payload arrived as 7,312 bytes, silently corrupting the file with no error raised. Anything above roughly 10 KB is unsafe, which rules out essentially every real screenshot.
Reading server-side also makes the returned contentLength and sha256 facts
about the file rather than facts about the transport, so a caller can verify them
against the source. Compare with Get-FileHash -Algorithm SHA256 <file>.
image/png, image/jpeg, image/webp and image/gif, up to 10 MB. The type is
determined from the file's magic bytes, not its extension, and a file whose
extension disagrees with its content is rejected rather than uploaded.
SVG is rejected outright — it can carry script and external references, and the
platform's own content-type allowlist excludes it. Non-image files (PDF, .docx,
plain text) are also rejected: the platform has no storage for them.
These follow from the platform having no attachment entity — images are presigned S3 uploads referenced by storage key, with no table, no metadata and no delete endpoint. Removing them needs a backend change, not a change here.
Images only. No PDF, .docx or text attachments.
delete_attachment unlinks, it does not delete. It removes the reference
from a document; the stored object remains and stays readable by anyone holding
a signed URL. Don't tell a user their file has been erased.
No garbage collection. Attachments uploaded but never referenced by a saved
document are reported on stderr after MEETRUPERT_ATTACHMENT_TTL_MS, not
reclaimed. (Orphans are not unique to this server — the web editor presigns an
upload before the user saves and records nothing, so an abandoned edit leaks an
object the same way.)
filename and sha256 are advisory. They are returned at creation and not
persisted, because there is nowhere to persist them.
path fails closed. Reads are confined to MEETRUPERT_ATTACHMENT_DIRS,
which is empty by default, so path is refused until an operator opts in.
Symlinks are resolved before the containment check and containment is compared
on path segments, so neither a symlink nor a .. nor a same-prefix sibling
directory (/srv/uploads-evil vs /srv/uploads) can escape.
source_url is SSRF-hardened. HTTPS only; private, loopback, link-local,
CGNAT and cloud-metadata ranges are blocked after DNS resolution, with the
connection pinned to the vetted address so a rebind cannot land elsewhere;
redirects are not followed; connect and read timeouts apply; and the size cap is
enforced per chunk while streaming, aborting the transfer rather than checking
after the download completes.
Tenancy. Storage keys are always built from the resolved org id, never from caller input, so an attachment is only reachable within the workspace that created it. The backend independently enforces the same prefix.
Logging. Filenames, byte counts and checksums only — never file contents, and attachment bytes are never placed in an error message or stack trace. Fetched URLs have credentials and query strings redacted.
npm install
cp .env.example .env # then fill in credentials
npm run build.env)Variable | Required | Description |
| yes | Service user's email. |
| yes | Service user's password. |
| no | API base URL incl. |
| no | Override the organisation. Defaults to the logged-in user's org. |
| no | Directories |
| no | Per-attachment size cap. Defaults to |
| no | How long before an unreferenced attachment is reported as an orphan. Defaults to |
claude_desktop_config.json or .claude/settings.json){
"mcpServers": {
"meetrupert": {
"command": "node",
"args": ["/path/to/meet-rupert-mcp/dist/index.js"],
"env": {
"MEETRUPERT_EMAIL": "service-user@yourdomain.com",
"MEETRUPERT_PASSWORD": "…",
"MEETRUPERT_BASE_URL": "https://app.meetrupert.com/api"
}
}
}
}The env block can be omitted if a .env file sits next to the server (env is
loaded relative to the built file, not the host's working directory). You can
also add it interactively via /mcp in Claude Code.
npm run typecheck # tsc --noEmit
npm run build # tsup → dist/
npm run dev # rebuild + restart on change
npm start # node dist/index.js
npm test # vitest — Tiptap converters, SSE parser, attachmentsThe attachment tests cover round-trip sha256 integrity, the size cap on every
input path (including a body that only breaches it partway through streaming),
extension/magic-byte mismatch, path traversal via .. and via symlink, SSRF
against private and metadata addresses, cross-tenant reads, and a document
referencing an unknown attachment:// id failing without saving.
Ask the Meet Rupert AI a natural-language question. It runs Retrieval-Augmented Generation over the PUBLISHED documents in the knowledgebase and returns a synthesised answer plus the source documents it used (with their documentIds, which you can pass to read_document). This is a one-shot question with no memory of previous calls — use create_chat_thread + ask_in_thread for a multi-turn conversation.
Inputs: question (required), categoryIds.
Ask a question within an existing conversation thread. The AI answers with the thread's prior messages as context (so follow-ups like "and what about X?" work), running RAG over the published knowledgebase. Returns the answer plus source documents. Both your question and the answer are saved to the thread.
Inputs: question (required), threadId (required), categoryIds.
Upload an image so it can be embedded in a Meet Rupert document. PASS A FILE PATH OR AN HTTPS URL — NOT THE IMAGE DATA. The server reads the bytes itself; there is no base64 or inline-content parameter and you must not attempt to supply one. This is because a large payload placed in a tool-call argument gets silently truncated in transit (an 18,880-byte payload arrived as 7,312 bytes in testing, corrupting the file with no error raised), which rules out essentially every real screenshot. Letting the server read the file makes the returned contentLength and sha256 facts about the file itself, so you can verify them against the source. Accepts image/png, image/jpeg, image/webp and image/gif only, up to 10 MB — the type is determined from the file's magic bytes, not its extension. SVG and non-image files (PDF, .docx, plain text) cannot be attached: the platform has no storage for them. Returns an attachmentId and a ready-to-use markdownRef like  — put that in the content of create_document or update_document to place the image.
Inputs: path, caption, source_url.
Create a new conversation thread for multi-turn Q&A with the Meet Rupert AI. Returns a threadId to pass to ask_in_thread. The thread's title is generated by the platform. Use this when follow-up questions need to remember earlier context; for a single standalone question use ask_ai.
Inputs: no named parameters.
Create a new document in the Meet Rupert knowledgebase. Provide the body as Markdown; it is converted to the platform's rich-text format. By default the document is saved as a DRAFT (not searchable by the AI) so a human can review it before publishing — pass published:true to make it live immediately. Returns the new document's id. To embed images, upload each one with create_attachment (which takes a file path or an https:// URL — never image data) and place the markdownRef it returns in content. Every attachment:// reference is verified before saving: if one is unknown or belongs to another workspace the save fails naming the offending id, rather than storing a broken image.
Inputs: title (required), content (required), published, categoryIds.
Remove an image from a document by deleting its reference from the document body. IMPORTANT: this does NOT delete the stored image itself — the Meet Rupert platform exposes no endpoint for that, so the object remains in storage and stays reachable by anyone holding a signed URL. Treat this as 'unlink from document', not 'delete'. Genuine deletion needs a platform change; do not tell a user their file has been erased.
Inputs: documentId (required), attachmentId (required).
Download a stored attachment, either by writing it to a file path the server can reach (destPath) or by returning a short-lived signed URL (signedUrl:true). Returns the byte length and sha256 of what was written so you can verify it against the original. Image bytes are never returned inline — that is the same truncation hazard create_attachment exists to avoid, and a path plus a checksum is what verifying integrity actually needs.
Inputs: attachmentId (required), destPath, signedUrl.
List the images embedded in a Meet Rupert document, with each one's attachmentId, alt text and whether it still resolves in storage. Use this to find the id of an image you want to download or remove, or to check a document for broken images.
Inputs: documentId (required).
List the document categories in the knowledgebase, with their UUIDs and document counts. Use these ids for the categoryIds parameter when creating/updating documents or when scoping ask_ai retrieval.
Inputs: no named parameters.
List your recent Meet Rupert conversation threads with their titles and threadIds, so you can resume one with ask_in_thread. Returns the most recent threads first.
Inputs: no named parameters.
Read a single Meet Rupert document by its UUID. Returns the title, metadata, and the document body converted to Markdown for easy reading. Get the documentId from search_documents or from an ask_ai source reference. Embedded images come back as  references. Those are stable and can be passed straight back to update_document — keep them in the body to preserve the images, and use list_attachments or download_attachment if you need the files themselves.
Inputs: documentId (required).
Search the Meet Rupert knowledgebase for documents by title. Returns a paginated list of matching documents with their UUIDs, titles, draft status, categories and last-updated dates. Use the returned id with read_document to fetch full content. This is a title/metadata search — to ask a natural-language question answered from document content, use ask_ai instead.
Inputs: page, query, pageSize.
Edit an existing Meet Rupert document. Any field you omit is left unchanged — pass only what you want to change. content (Markdown) replaces the entire document body, so read_document first if you're making a partial edit. Each update snapshots a new version and re-indexes the document for AI search. Returns the updated document's id and state. Because content replaces the whole body, any attachment:// ref you drop from it removes that image from the document — preserve the refs read_document gave you. Add new images via create_attachment, never by pasting image data.
Inputs: documentId (required), title, content, published, +1 more.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 13 tools
Each tool targets a distinct resource and action, with clear separation between document CRUD, attachment management, and AI chat. Descriptions explicitly clarify potential overlaps like search_documents vs ask_ai and ask_ai vs ask_in_thread, so an agent should not confuse them.
All tool names follow a consistent verb_noun pattern (read_document, create_attachment, list_categories), with AI queries uniformly using ask_* (ask_ai, ask_in_thread). There are no mixed conventions or vague verbs.
13 tools cover documents, attachments, and chat threads without unnecessary bloat. The scope is well-defined for a knowledgebase server, and each tool has a clear role in the workflow.
The document lifecycle is missing delete_document, which is a notable gap given create, read, and update are all present. Additionally, search_documents only searches by title, so there is no straightforward way to list all documents. Attachment deletion is intentionally not a true delete, but that is explicitly documented as a platform limitation.
Search, read, create and edit your Memol notes from Claude. Team note-taking with AI search.
Connect your team's living knowledge base — docs, data, issues, CRM — to Claude and ChatGPT.
Work with your DealSharp negotiation projects, documents and tools from Claude.
Your docs site. No editor to open. Just ask Claude.
