The tapir-archicad-mcp server bridges AI agents (like Claude) with running Archicad instances, providing a unified toolset of 191+ commands from the Tapir and official Archicad JSON APIs. Key capabilities:
Instance Discovery: Scan for all active Archicad instances, retrieving port numbers, project names, types, and versions.
Progressive Command Execution: List available commands with descriptions, fetch their exact JSON schemas, then execute any command with validated parameters, targeting a specific instance by port.
Multi-Instance Control: Manage and interact with multiple Archicad instances simultaneously.
Architectural Manipulation: Query and modify elements (walls, slabs, doors, etc.) and model data.
Flexible & Secure Transports: Supports stdio, SSE, and streamable HTTP, with optional Bearer token authentication for remote access.
Cross-Platform: Works on Windows and macOS.
Runtime Validation: All tool arguments are strictly validated using Pydantic-generated schemas.
Provides tools for interacting with Archicad projects, including discovering and calling commands to manage elements, layers, views, and more via the Tapir and official Archicad JSON APIs.
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., "@tapir-archicad-mcp check what Archicad projects I have running"
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.
This project provides a Model Context Protocol (MCP) server for Archicad. It acts as a bridge, allowing AI agents and applications (like Claude for Desktop) to interact with running Archicad instances by wrapping both the community-driven Tapir API and the official Archicad JSON API.
The server dynamically generates a comprehensive set of 191+ MCP tools from the combined API schemas, enabling fine-grained control over Archicad projects.
Pydantic-Powered Runtime Validation & Schema Generation: Every tool's input and output shapes are backed by rigorous Pydantic models. The server dynamically compiles these into detailed JSON Schemas for the AI agent to inspect, and strictly validates all incoming tool arguments at runtime before forwarding them to Archicad. It handles complex models, Union types, and TypeAliases seamlessly.
Progressive Tool Discovery (CLI-style): The server uses a deterministic workflow (archicad_list_commands and archicad_get_command_schema) that allows AI agents to list available commands and fetch exact parameter schemas on demand. This avoids flooding the model's context window with large schemas.
No Heavy Machine-Learning Dependencies: Vector-based search has been removed. The server no longer requires heavy packages like PyTorch, faiss-cpu, or sentence-transformers, dramatically reducing the package size and eliminating server startup delays.
Massive Toolset, Minimal Footprint: Provides access to a unified toolset of 191+ commands by merging the community Tapir API and the official Archicad JSON API.
Flexible Network Transports: Supports sse (Server-Sent Events) and streamable-http transports in addition to standard input/output (stdio), allowing the server to be run on remote host configurations.
Bearer Token Authentication: Secures HTTP endpoints when using SSE or Streamable-HTTP via an opt-in token validation middleware (--token flag or TAPIR_MCP_TOKEN environment variable).
Multi-Instance Control: Connect to and manage multiple running Archicad instances simultaneously, targeting commands to specific instances via port numbers.
Cross-Platform Support: Compatible with both Windows and macOS systems.
Related MCP server: Fusion360 MCP Server
Follow these steps to get the server running and connected to an MCP client like Claude for Desktop.
Python 3.12+ and uv: Ensure you have a modern version of Python and the uv package manager installed.
Archicad & Tapir Add-On: You must have Archicad running (which includes the official JSON API). To access the full set of community-developed tools, the Tapir Archicad Add-On must also be installed.
MCP Client: An application that can host MCP servers, such as Claude for Desktop or Gemini CLI.
Open your client's config.json file and add the following configuration. This command works across operating systems:
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APDATA%\Claude\claude_desktop_config.json
{
"mcpServers": {
"ArchicadTapir": {
"command": "uvx",
"args": [
"--from",
"tapir-archicad-mcp",
"archicad-server"
]
}
}
}If your client supports MCP Bundles you can skip the config file above. Claude Desktop, Claude Code and MCP for Windows all install .mcpb files.
Download tapir-archicad.mcpb from the latest release and open it in your client. On the Microsoft Store build of Claude Desktop this is the easier route, because the app does not read the %APPDATA%\Claude\claude_desktop_config.json that everyone documents.
uv still has to be on the PATH your client sees, but it provisions Python and the locked dependencies itself, so there is nothing else to install. The first launch takes 15 to 30 seconds while it builds that environment. The bundle can modify the open project, export files, and send or receive Teamwork, so treat installing it like handing your client your Archicad seat.
"Server disconnected", or the install itself fails. Uninstall the bundle, restart the client, then install it again. Installing over an existing bundle can leave stale state behind that a straight reinstall does not clear.
Nothing happens for the first half minute. That is uv building the environment, and antivirus scanning or a slow connection stretches it out. Restart the client once before assuming the bundle is broken.
Claude Desktop logs are at %APPDATA%\Claude\logs\mcp-server-Archicad (Tapir).log. On the Microsoft Store build that path is redirected and the real file is %LOCALAPPDATA%\Packages\Claude_pzs8sxrjxfjjc\LocalCache\Roaming\Claude\logs\mcp-server-Archicad (Tapir).log.
Icon artwork is the official Tapir mark from ENZYME-APD/tapir-archicad-automation (branding/logo/png/tapir_logo_black_512.png), MIT, Copyright 2024 Enzyme APD.
You can customize the server via CLI flags or environment variables:
CLI Flag | Environment Variable | Default | Description |
| - |
| Transport protocol to use ( |
|
|
| Bind address for HTTP-based transports |
|
|
| Bind port for HTTP-based transports |
|
|
| Optional Bearer token to secure HTTP endpoints |
Restart Claude for Desktop to apply configuration changes.
Ensure at least one instance of Archicad is running.
The client will initially have access to a small set of core tools. Start by asking the AI to find running Archicad instances:
"Can you check what Archicad projects I have running?"
The AI will call discovery_list_active_archicads and report the active instances and their port numbers.
State your main goal:
"Using port 19723, get all the Wall elements from the project."
The AI will execute a progressive discovery and calling loop:
Step 1: It queries archicad_list_commands to look up the correct command name for the requested action (identifying elements_get_elements_by_type).
Step 2: It calls archicad_get_command_schema with the target command name to retrieve the exact required JSON parameter structure.
Step 3: It calls archicad_call_tool with the command name, the targeted port, and the required parameter payload.
The server operates through a layered architecture:
AI Agent (e.g., Claude): Interprets user prompts and orchestrates tool discovery.
MCP Client (e.g., Claude for Desktop): Manages the server process and handles communication.
MCP Server (This Project): Standardizes tool descriptions, parameters, and results, presenting a clean list/schema/call interface.
multiconn_archicad Library: Resolves active socket connections and handles low-level command dispatch to Archicad instances.
Archicad & Tapir Add-On: Built-in APIs and Tapir Add-on execute commands and return structured data.
Contributions are welcome! Please feel free to submit an issue or open a pull request.
This project is licensed under the MIT License. See the LICENSE file for details.
Executes a specific Archicad API command by its 'name'. CRITICAL WORKFLOW: You MUST use 'archicad_get_command_schema' first to understand the exact JSON structure required for the 'arguments' parameter. The 'arguments' dictionary MUST contain a 'port' number (from 'discovery_list_active_archicads'). If a tool's response includes a 'next_page_token', call this same tool again with the same parameters and add a 'page_token' key to the 'arguments' dictionary.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | ||
| arguments | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses critical workflow dependencies, port requirement, and pagination behavior via 'next_page_token'. It does not state load safety or side-effect profile, but the provided behavioral details are meaningful and non-obvious.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, then provides critical workflow in a concise, imperative manner. Every sentence adds value, and the length is appropriate for the complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool is a generic execution gateway with no output schema and sparse input schema, the description adequately covers the essential workflow: schema retrieval, port requirement, and pagination. It could mention error handling or return format, but the reference to the schema tool handles command-specific details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description compensates by explaining that 'name' is the command and that 'arguments' must include 'port' and optionally 'page_token'. It also directs users to 'archicad_get_command_schema' for exact structure, adding significant semantic value over the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Executes a specific Archicad API command by its name' with a specific verb and resource. It distinguishes itself from siblings like listing commands, discovery, or getting schemas by focusing on execution.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides strong usage context: MUST call 'archicad_get_command_schema' first, includes 'port' from 'discovery_list_active_archicads', and explains pagination handling. It lacks explicit when-not-to-use instructions, but the workflow guidance is clear and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieves the exact JSON schema (required arguments) for a specific Archicad command. Provide the exact 'command_name' obtained from 'archicad_list_commands'. CRITICAL: You MUST call this tool before executing 'archicad_call_tool' to ensure you provide the correct parameters. Do NOT guess or hallucinate parameters based on the command name.
| Name | Required | Description | Default |
|---|---|---|---|
| command_name | Yes |
| Name | Required | Description |
|---|---|---|
| name | Yes | The name of the command. |
| input_schema | Yes | The JSON schema outlining the required arguments for archicad_call_tool. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses that the command_name must be exact and obtained from archicad_list_commands, and strongly warns against hallucinating parameters. The read-only nature is implied by 'retrieves', but error behavior (e.g., invalid command_name) is not disclosed. Given the tool's simplicity, this is reasonable transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, with the purpose first and the critical workflow instruction second. Every sentence is necessary; it is concise, front-loaded, and has no fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with one parameter and no schema descriptions, the description covers purpose, parameter source, and usage context. It doesn't detail return formatting, but an output schema exists, so that is not required. Minor gap: it doesn't mention prerequisite like an active Archicad connection, but sibling discovery tools imply that.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema only provides a title for 'command_name' (0% schema description coverage), but the description compensates fully by specifying that the value must be the exact command name from 'archicad_list_commands'. This adds precise semantic meaning and source for the only parameter, eliminating ambiguity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it 'Retrieves the exact JSON schema (required arguments) for a specific Archicad command.' This uses a specific verb ('retrieves') and distinct resource (JSON schema for a command), effectively distinguishing it from sibling tools like archicad_list_commands (lists commands) and archicad_call_tool (executes commands).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit usage context: instructs to provide the exact command_name from 'archicad_list_commands' and mandates calling this tool before 'archicad_call_tool' to avoid guessing parameters. This clearly states when and how to use the tool, and implies alternatives by referencing the sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns a comprehensive list of all available Archicad API commands and brief descriptions. STEP 1: Use this tool FIRST to search for the right command name for your task. Do NOT guess or hallucinate command names. STEP 2: Once you find the relevant command name, you MUST use the 'archicad_get_command_schema' tool to learn its exact required arguments.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral disclosure burden. It discloses that the tool returns a comprehensive list with brief descriptions and clarifies it does not provide exact arguments, directing to the schema tool. It does not mention any connection requirements or output size, but is generally transparent for a simple listing tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three concise sentences lead with the primary behavior, then deliver stepwise instructions without redundancy. The STEP 1/STEP 2 formatting makes the flow easy to follow and every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (no parameters) and the presence of an output schema, the description fully covers purpose, usage flow, and relation to sibling tools. It leaves no obvious gaps for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and the schema is empty, so the baseline is 4. The description adds contextual workflow guidance about how to use the returned command names, which is relevant even without parameter details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool 'Returns a comprehensive list of all available Archicad API commands and brief descriptions,' identifying the exact verb, resource, and scope. It also distinguishes this from sibling tools by framing it as the discovery step for finding command names.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit step-by-step guidance is provided: 'STEP 1: Use this tool FIRST' and 'STEP 2: ... MUST use the archicad_get_command_schema tool.' It warns against guessing or hallucinating command names and names the specific alternative tool to use next, giving both when-to-use and when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Scans for and lists all running Archicad instances that the server can connect to. Each instance is identified by a unique 'port' number. This 'port' is required to target any other command.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Describes scanning behavior but does not explicitly state that the operation is read-only or non-destructive. Lacks details on permissions, network usage, or potential side effects, though implied safe by nature.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, 25 words. Front-loaded with purpose; second sentence adds essential context about port usage. No redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Has output schema (not detailed but present), no parameters. Description adequately covers purpose and how output is used. Could mention that the list includes port numbers and possibly other fields, but sufficient for task.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters in schema (schema coverage 100%). Baseline is 4 per rules. Description adds no parameter info, but none needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states the tool scans for and lists all running Archicad instances. Identifies the resource ('running Archicad instances') and the action ('scans for and lists'). Differentiates from siblings by focusing on instance discovery rather than calling tools or discovering tool definitions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implicitly guides usage by stating the listed port is required for other commands, indicating this tool should be used first. Does not explicitly mention when not to use it or provide alternatives, but sibling tool names suggest distinct purposes.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.5.1archicad_discover_toolsarchicad_get_command_schemaarchicad_list_commandsv0.4.3archicad_call_toolarchicad_discover_toolsdiscovery_list_active_archicadsScored across 4 tools
Each tool has a distinct purpose: one lists commands, one discovers instances, one retrieves schemas, and one executes commands. There is no overlap or ambiguity between them.
Tool names follow a consistent [prefix]_[verb]_[noun] pattern, but the prefixes vary ('archicad_' vs 'discovery_'), which is a minor inconsistency. Overall the naming is clear and predictable.
With 4 tools, the server is well-scoped. It provides just the right set for a meta-API bridge: discovery, schema lookup, and execution.
The toolset covers the complete workflow: list available commands, get schema for a command, discover instances, and execute commands with pagination support. No obvious gaps for its stated purpose.
Human-input bridge for AI agents with voice-first answer links, MCP tools, and HTTP APIs.
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Connects AI assistants to QCDatabase.AI for everyday construction quality-control work.
AI Hub for AEC — 50+ 3D formats, clash detection, ACC integration via Autodesk Platform Services.
