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: archicad-mcp
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 |
|
|
| Seconds to wait before returning a running job handle |
|
|
| Seconds to keep finished jobs; |
|
|
| Maximum number of finished jobs to keep |
CLI flags override environment variables.
Commands normally return their result directly. If a command takes longer than 45 seconds, archicad_call_tool returns a job handle while execution continues:
{"status": "running", "jobHandle": "job:83af21..."}Call archicad_get_job(job_handle="job:83af21...") to check progress and retrieve the result. Repeat while the status is running; the final status is completed or failed. If your client times out sooner, lower --async-threshold-seconds.
If a response is lost, call archicad_get_job() to list recent jobs before repeating a command that changes the project. Cancelling a request does not stop a command already started, and retrying it may duplicate changes.
Jobs remain available across HTTP client reconnects while the server is running, but are lost on server restart. Retention defaults to 24 hours and a maximum of 128 finished jobs.
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 (obtained 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. Long executions return status='running' and a jobHandle; retrieve them with archicad_get_job. If a response is lost or cancelled, list jobs with archicad_get_job() before retrying a write. Cancelling this request does not cancel an admitted execution.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | ||
| arguments | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare destructiveHint=true, idempotentHint=false and openWorldHint=true, and the description adds substantial behavioral context beyond them: long executions return status='running' with a jobHandle, pagination via page_token, and the critical caveat that 'Cancelling this request does not cancel an admitted execution'. That last detail is exactly the kind of non-obvious write semantics an agent needs.
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?
Dense but front-loaded: the core action comes first, then a labeled CRITICAL WORKFLOW, then edge cases. Every sentence carries operational information, though the paragraph is longer than strictly necessary for a two-parameter tool.
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 an open-ended dispatcher with no output schema, the description covers the full lifecycle: prerequisite schema lookup, required port, pagination, asynchronous job handles, retrieval, retry caution, and cancellation semantics. An agent has everything needed to call it correctly and to interpret the two response shapes.
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% and 'arguments' is an open nested object, so the description must compensate. It does: 'arguments' must contain a 'port' number sourced from discovery_list_active_archicads, may need a 'page_token', and 'name' must correspond to a command validated via archicad_get_command_schema. It stops short of 5 only because it never enumerates any concrete command names or argument keys.
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?
States a specific verb ('Executes') and resource ('a specific Archicad API command') and clarifies that the command is selected by the 'name' parameter, which distinguishes it from archicad_list_commands and archicad_get_command_schema. It is a generic dispatcher rather than a domain-specific operation, so it stops short of a 5.
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?
Explicitly prescribes the workflow: call archicad_get_command_schema first for the exact JSON structure, obtain 'port' from discovery_list_active_archicads, and use archicad_get_job to retrieve long-running executions. It also gives a conditional rule (next_page_token) and a when-not-to-retry rule ('list jobs before retrying a write'), leaving nothing to inference.
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?
Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds useful behavioral context by stating the mandatory precondition that this must be called before archicad_call_tool, which clarifies the tool's role in the workflow beyond what the annotations express.
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 tight sentences with the core purpose front-loaded. Every sentence earns its place: what it does, where the input comes from, and the critical workflow constraint. No filler or repetition.
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 single-parameter, read-only tool with a full output schema and clear sibling context, the description is complete. It covers input provenance, the required call order relative to archicad_call_tool, and the anti-hallucination warning. Return value details are appropriately left to the output schema.
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 schema itself has 0% description coverage, so the description carries the burden for parameter meaning. It compensates well by specifying that command_name must be the exact value obtained from 'archicad_list_commands' and explicitly warns against guessing, which adds real semantic value beyond the raw 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 uses a specific verb and resource: 'Retrieves the exact JSON schema (required arguments) for a specific Archicad command.' It clearly differentiates from sibling tools by naming archicad_list_commands and archicad_call_tool and placing itself between them in the workflow.
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?
The description gives explicit when-to-use guidance: call after obtaining command_name from 'archicad_list_commands' and before executing 'archicad_call_tool'. It also tells the agent not to guess or hallucinate parameters, which is direct and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
With no job_handle, immediately lists all retained executions newest first, including fast, completed, and failed jobs, with command, port, timestamps, and a short argumentsPreview. Use this to recover after a lost response before retrying a write; similar calls may be ambiguous. With a job_handle, waits up to the configured threshold and returns running, completed with result, or failed with error. Polling never redispatches commands.
| Name | Required | Description | Default |
|---|---|---|---|
| job_handle | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover safety (readOnly, idempotent, non-destructive), but the description adds genuinely new behavioral facts: newest-first ordering, wait-up-to-threshold semantics, the running/completed/failed result states, the argumentsPreview field, and the key guarantee that 'polling never redispatches commands.' That last point is exactly the kind of side-effect disclosure an agent needs.
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 dense sentences, front-loaded with the no-argument behavior, and every clause adds information (ordering, result states, no-redispatch guarantee). Slightly packed for one breath, but there is no filler.
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?
With no output schema, the description must describe returns, and it does: command, port, timestamps, argumentsPreview for the list mode and running/completed-with-result/failed-with-error for the wait mode. Combined with the annotation-covered safety profile, an agent has everything needed to call this correctly.
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% and the single parameter has no description, so the description carries the burden and does so well: it explains that omitting job_handle triggers listing and supplying it triggers a blocking wait. It does not clarify the accepted handle format or where a handle is obtained, so it falls just short of full compensation.
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 states a precise dual behavior: with no job_handle it lists retained executions, with a job_handle it waits for and returns that job's outcome. This unambiguously separates it from write-oriented siblings like archicad_call_tool and from discovery tools, and an agent can pick the correct mode without opening the schema.
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?
It gives explicit when-to-use guidance ('use this to recover after a lost response before retrying a write') and a caution that 'similar calls may be ambiguous.' It stops short of naming an alternative sibling tool for retry decisions, so it is clear but not a full when/when-not/alternatives statement.
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?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds some output scope detail ('comprehensive list', 'brief descriptions') but does not disclose additional behavioral traits such as payload size, pagination, or response structure. It provides useful workflow context but not deeper behavioral 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 compact, front-loaded with the core purpose, and uses a clear STEP 1/STEP 2 structure. Every sentence earns its place, and the most important instruction—use this first—is prominent.
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 zero-parameter discovery tool with an output schema and rich annotations, the description is complete. It tells the agent exactly what the tool returns, when to use it first, and which sibling tool to proceed with. Nothing needed to call it correctly is missing.
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, so the baseline is 4 and the description need not explain argument semantics. The empty input schema already makes clear that no arguments are required, and the description focuses on the tool's role rather than introducing unnecessary 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, using a specific verb and resource. It also differentiates itself from sibling tools by explicitly positioning itself as the discovery step before calling archicad_get_command_schema.
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?
The description gives explicit step-by-step guidance: use this tool FIRST to find the correct command name, do not guess or hallucinate names, and then use archicad_get_command_schema to learn exact arguments. This clearly states when to use this tool and what to do next.
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 running Archicad instances. Returns 'active' (ready to receive commands with their target 'port') and 'unavailable' (instances that are unresponsive or missing the Tapir Add-On).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| activeInstances | No | List of ready Archicad instances that can be targeted by commands. |
| unavailableInstances | No | List of detected instances that cannot be targeted, along with diagnostic reasons. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare read-only, open-world, idempotent, and non-destructive behavior, so the description does not need to repeat those. It adds valuable behavioral context by explaining what 'active' means, that ports are provided, and that 'unavailable' instances may be unresponsive or missing the Tapir Add-On. No contradiction with annotations.
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 concise sentences with no filler. The core action is front-loaded, and the second sentence adds meaningful output clarification without redundancy.
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 simple, parameterless discovery tool with safety annotations and an output schema, the description is complete. It explains what the tool returns, what the categories mean, and why an instance might be unavailable, which is all an agent needs to select and interpret the tool correctly.
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, so the schema provides no parameter details to supplement. The description correctly focuses on behavior and return categories instead, which is appropriate for a parameterless discovery tool.
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 states a specific verb ('Scans for and lists') and resource ('running Archicad instances'), making the tool's function immediately clear. It also goes beyond a simple label by explaining the two output categories, 'active' and 'unavailable', which distinguishes it from sibling tools that deal with commands and schemas.
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?
The description makes the usage context clear: it identifies which instances are ready to receive commands and provides their target ports, implying it should be used before calling command-execution tools. It does not explicitly name alternatives or state when not to use it, but the intended role is evident from the active/unavailable distinction.
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.6.5archicad_get_jobv0.6.0archicad_list_commands1 field changedOutput schema / $defs / CommandOverview / properties / name / descriptionPrevious value: -"The unique, snake-cased name of the tool (e.g., 'elements_get_all_elements'). Use this in archicad_get_command_schema."New value: +"The unique, snake-cased name of the tool (e.g., 'elements_get_all_elements')."discovery_list_active_archicads9 fields changedOutput schema / $defs / ArchicadInstanceInfoRemoved value: -{
- "description": "A curated model to hold key information about a running Archicad instance.",
- "properties": {
- "archicadVersion": {
- "description": "The major version of the Archicad application (e.g., '27').",
- "title": "Archicadversion",
- "type": "string"
- },
- "port": {
- "description": "The communication port of the Archicad instance. Use this to target commands.",
- "title": "Port",
- "type": "integer"
- },
- "projectName": {
- "description": "The name of the project file currently open in the instance.",
- "title": "Projectname",
- "type": "string"
- },
- "projectPath": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "The full file path of the project, if it is a saved solo or teamwork project.",
- "title": "Projectpath"
- },
- "projectType": {
- "description": "The type of the project: 'teamwork', 'solo', or 'untitled'.",
- "enum": [
- "teamwork",
- "solo",
- "untitled"
- ],
- "title": "Projecttype",
- "type": "string"
- }
- },
- "required": [
- "port",
- "projectName",
- "projectType",
- "archicadVersion"
- ],
- "title": "ArchicadInstanceInfo",
- "type": "object"
-}Output schema / $defs / ReadyInstanceAdded value: +{
+ "description": "Information about an active Archicad instance ready to execute commands.",
+ "properties": {
+ "archicadVersion": {
+ "description": "The major version of Archicad (e.g. '27', '28').",
+ "title": "Archicadversion",
+ "type": "string"
+ },
+ "port": {
+ "description": "The communication port of the Archicad instance. Pass this to archicad_call_tool.",
+ "title": "Port",
+ "type": "integer"
+ },
+ "projectName": {
+ "description": "The name of the currently open project.",
+ "title": "Projectname",
+ "type": "string"
+ },
+ "projectPath": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ],
+ "default": null,
+ "description": "The full file path or teamwork server location of the project.",
+ "title": "Projectpath"
+ },
+ "projectType": {
+ "description": "The type of the project: 'teamwork', 'solo', or 'untitled'.",
+ "enum": [
+ "teamwork",
+ "solo",
+ "untitled"
+ ],
+ "title": "Projecttype",
+ "type": "string"
+ },
+ "tapirVersion": {
+ "description": "The version of the Tapir Add-On installed on this instance.",
+ "title": "Tapirversion",
+ "type": "string"
+ },
+ "warning": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ],
+ "default": null,
+ "description": "Warning regarding Tapir version differences (e.g., outdated or newer version).",
+ "title": "Warning"
+ }
+ },
+ "required": [
+ "port",
+ "projectName",
+ "projectType",
+ "archicadVersion",
+ "tapirVersion"
+ ],
+ "title": "ReadyInstance",
+ "type": "object"
+}Output schema / $defs / UnavailableInstanceAdded value: +{
+ "description": "Diagnostic information about an Archicad instance that cannot be automated.",
+ "properties": {
+ "message": {
+ "description": "Explanation and actionable troubleshooting advice.",
+ "title": "Message",
+ "type": "string"
+ },
+ "reason": {
+ "description": "Why the instance is unavailable: 'missing_tapir' or 'unresponsive'.",
+ "enum": [
+ "missing_tapir",
+ "unresponsive"
+ ],
+ "title": "Reason",
+ "type": "string"
+ }
+ },
+ "required": [
+ "reason",
+ "message"
+ ],
+ "title": "UnavailableInstance",
+ "type": "object"
+}Output schema / descriptionAdded value: +"The result of scanning for Archicad instances."Output schema / properties / activeInstancesAdded value: +{
+ "description": "List of ready Archicad instances that can be targeted by commands.",
+ "items": {
+ "$ref": "#/$defs/ReadyInstance"
+ },
+ "title": "Activeinstances",
+ "type": "array"
+}Output schema / properties / resultRemoved value: -{
- "items": {
- "$ref": "#/$defs/ArchicadInstanceInfo"
- },
- "title": "Result",
- "type": "array"
-}Output schema / properties / unavailableInstancesAdded value: +{
+ "description": "List of detected instances that cannot be targeted, along with diagnostic reasons.",
+ "items": {
+ "$ref": "#/$defs/UnavailableInstance"
+ },
+ "title": "Unavailableinstances",
+ "type": "array"
+}Output schema / requiredRemoved value: -[
- "result"
-]Output schema / titlePrevious value: -"list_active_archicadsOutput"New value: +"DiscoveryResult"v0.5.1archicad_discover_toolsarchicad_get_command_schemaarchicad_list_commandsv0.4.3archicad_call_toolarchicad_discover_toolsdiscovery_list_active_archicadsScored across 5 tools
Each tool has a distinct role in the workflow: discovery, listing commands, fetching schemas, executing commands, and retrieving jobs. However, archicad_get_job has a dual purpose (listing all jobs vs. waiting for a specific job) and archicad_call_tool is a generic catch-all, which could cause minor confusion about when to use each.
Most tools use snake_case with an archicad_ prefix and follow a verb_noun pattern (get_job, get_command_schema, list_commands). The exceptions are archicad_call_tool (vague verb_tool) and discovery_list_active_archicads (different prefix), but overall the convention is readable and mostly consistent.
Five tools is well-scoped for a proxy server that exposes a large external API through a single generic executor. Each tool covers a necessary meta-operation, and no tool feels redundant or missing from the core set.
The surface covers the full lifecycle: discover instances, list commands, inspect schemas, execute commands, and track jobs. Minor gaps include no explicit job cancellation tool and no bulk schema retrieval, but agents can work around these.
Connect your AI assistant to Blender for 3D modeling, Geometry Nodes, materials, lighting, animation, rendering and export. Inspect real scenes and viewport images, refine the result and restore checkpoints. OAuth connects your chat to Blender Bridge Desktop on an online Windows 10/11 x64 computer running Blender 4.2+. The chat can run on another device. Requires an active Blender Bridge account; 7-day trial available. AI model access is separate.
Human-input bridge for AI agents with voice-first answer links, MCP tools, and HTTP APIs.
Parametric 3D CAD for AI agents: build print-ready parts, check them, export STL, 3MF or STEP.
Kaiva Bridge turns your API, database or documents into a managed MCP server for Claude, ChatGPT, Cursor and VS Code. Point it at an OpenAPI or Swagger spec, an API docs link, a cURL command, a Postman collection, a GraphQL endpoint, Postgres, MySQL, MariaDB or SQL Server, spreadsheets, PDFs and other documents, or an MCP server you already run. Bridge reads the source and proposes tools, and you choose which ones your AI client sees. No code to write and nothing to run. Connect this server and your agent does the setup for you: it lists your servers, shows one, drafts a new server from an OpenAPI spec, and refreshes a server's tools when its API changes. Free plan: 10 servers and 200,000 tool calls a month, no credit card. Pricing: https://kaiv.ai/bridge/pricing Security: https://kaiv.ai/bridge/security Docs: https://kaiv.ai/bridge/docs
