Pinly Speaks MCP

Introduction

When designing Pinly, we’re pinning a good deal of our resources into making it easy and pleasant to use, constantly thinking about how we can improve your project collaboration experience. While clicks and buttons are great, modern tech allows us to interact with applications in other ways – say, in natural language, thanks to Model Context Protocol, a.k.a. MCP.

This update features changes to both our server application and the plug-in itself. This article will cover technical details, as well as notes on setup and use cases.

Tech stack – server-side

On our servers, the ModelContextProtocol package does the heavy lifting of generating and routing the tools.

Our main job is to thoroughly think about the integration workflow: what should be doable with MCP, and what shouldn’t; how to scope tools, so that they are not too broad, but also not too specific.

With MCP, a typical endpoint would look like this:

[McpServerTool, Description("Delete a comment with provided ID")]
public async Task<CallToolResult> DeleteComment([Description("Comment identifier")] Guid id) {
   // some tool call validation
   var deleted = await commentService.TryDeleteComment(id);

   var response = new
   {
       message = deleted ? "Comment was deleted" : "Comment was not deleted. Please try again",
   // other optional data for server-client communication
   };

   var responseText = JsonSerializer.Serialize(response);

   return new CallToolResult
   {
       Content =
       [
           new TextContentBlock
           {
               Text = responseText
           }
       ]
   };
}

Setting up

As we’re testing out the new feature, the setup workflow might seem convoluted — we feel for you and are working on optimizing everything as you’re reading this article. To get things working, we need to connect three parties: Revit, Pinly, and LLM client of your choice – we’ll cover Claude Code.
Revit:

Starting from version 2027, Revit provides native MCP connectivity. Earlier versions are not supported; however, third-party MCP connectors for Revit are available. How to setup your own MCP read this article

Pinly

First, download and install Pinly itself – we also offer free plans so you can try it out. Go to the “Integrations” tab of your Atomatiq account: your profile → Subscription → Integrations and issue a new MCP token. Keep it secure: it will be used to identify your profile.

LLM Client

In this article, Claude Code is used as the app of choice to orchestrate everything. However, any major desktop LLM client with MCP connectivity will work. For other clients, please reference official documentation on adding custom MCP connectors.

To add the servers to your CC, open command prompt and run these commands:

# hubs server: projects, hubs, memberships
claude mcp add --transport http hub-mcp https://api.hubs.atomatiq.io/mcp --header "Authorization: Bearer YOUR_PINLY_INTEGRATION_TOKEN_HERE"

# pinly server: threads, comments, resolving, etc.
claude mcp add --transport http hub-mcp https://api.pinly.atomatiq.io/mcp --header "Authorization: Bearer YOUR_PINLY_INTEGRATION_TOKEN_HERE"

Actual usage

With Revit MCP. Launch Revit and make sure your Revit MCP connector is running, then launch your LLM client. The assistant can now read the model through Revit MCP and write comments through Pinly MCP — for example, query a set of elements, validate a parameter, and place comments on the ones that fail, all in one flow.

Without Revit MCP. Pinly MCP doesn't depend on Revit MCP — it can run on its own. Revit doesn't even need to be open. The only requirement is that the assistant has the model context it needs to place a comment: a comment has to be pinned to something, so the assistant must know where to put it.

That context can come from anywhere:

• element IDs and coordinates the assistant already has from an earlier step or a previous Revit MCP session;
• data you provide directly in the conversation (e.g. an ID or location);
• another tool or source that supplies model references.

In other words, Revit MCP is one convenient way to feed the model context to the assistant — but not the only one. As long as the assistant knows what to attach a comment to, Pinly MCP can create, reply to, resolve, and manage comments completely independently of Revit. This is what makes Pinly a standalone "write" layer: any tool that understands your model can use it to place issues and comments that instantly become visible to the whole team, with no local Revit required.

Communication transparency

If a comment or a thread was created using AI, it will be marked with a colorful ✨ icon, visible to all users. This deliberate choice was made for several reasons:

• AI still has a rather specific writing style. You see a comment from your colleague, but the style is off: have they turned into a PR spokesperson overnight? No, that’s just an AI-generated comment.
• Trust calibration: AI can hallucinate; this is why there are “please double-check responses” messages on every chatbot. The icon reminds you: trust, but verify.
• It’s a way to let you know about a new feature. Try it out - you might find it very useful for your workflows.

Use cases

The current toolset allows you to work with threads and comments:

• Create new threads and delete them;
• Leave comments to existing threads;
• Edit comments;
• Mark threads as resolved, or unresolve them;

…as well as query information about your hubs and projects, such as:

• Available hubs & projects;
• Memberships within them – who is invited and in what role.

Now, you can easily do most of those things yourself — adding, deleting, and resolving threads is a matter of 1-2 mouse clicks. Where MCP really shines is filtering through a large amount of comments, and acting on them in batches. For example, you can:

• Find one specific thread that mentioned an issue;
• Leave comments to all threads that were opened more than a week ago and that are still not marked as resolved;
• Get all comments that are related to the scope that is in your responsibility;