MCP 服务器，用于将 AI 助手连接到 Tacit 建筑数字孪生。使用自然语言询问有关您的建筑、设备、传感器和区域的问题。
适用于 Claude Desktop、Claude Code、Cursor、Windsurf 以及任何兼容 MCP 的客户端。
四个只读工具：
工具 | 用途 |
| 列出您的 API 密钥可以访问的建筑 |
| 查询建筑知识图谱（符合 Brick 标准） |
| 获取历史传感器数据 |
| 列出站点的文档和文件 |
GraphQL 工具包含完整的模式参考，因此 AI 模型无需单独的文档即可编写查询。
Related MCP server: skyspark-mcp
npx -y @tacit/mcp-server只需将您的 MCP 客户端指向它（请参阅下方的配置）。无需克隆，无需构建。
git clone https://github.com/ucl-sbde/tacit-mcp.git
cd tacit-mcp
npm install
npm run build您需要一个 Tacit API 密钥。请在 app.betacit.com 的 Site Settings > API Keys 下获取。
标准方法 — MCP 客户端将服务器作为子进程启动。最适合在您自己的机器上个人使用。
编辑 ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) 或 %APPDATA%\Claude\claude_desktop_config.json (Windows)：
{
"mcpServers": {
"tacit": {
"command": "npx",
"args": ["-y", "@tacit/mcp-server"],
"env": {
"TACIT_API_KEY": "your-api-key"
}
}
}
}添加到项目中的 .mcp.json：
{
"mcpServers": {
"tacit": {
"command": "npx",
"args": ["-y", "@tacit/mcp-server"],
"env": {
"TACIT_API_KEY": "your-api-key"
}
}
}
}添加到 .cursor/mcp.json：
{
"mcpServers": {
"tacit": {
"command": "npx",
"args": ["-y", "@tacit/mcp-server"],
"env": {
"TACIT_API_KEY": "your-api-key"
}
}
}
}将服务器作为持久 HTTP 服务运行。最适合团队、云部署以及用户无法在本地安装 Node.js 的环境。
# Start the HTTP server
TACIT_API_KEY=your-api-key npm run start:http
# Or with npx
TACIT_API_KEY=your-api-key npx --package @tacit/mcp-server tacit-mcp-http服务器默认监听 http://0.0.0.0:3001/mcp。
使用 bearer token 将您的客户端指向服务器 URL：
{
"mcpServers": {
"tacit": {
"type": "streamable-http",
"url": "https://your-host:3001/mcp",
"headers": {
"Authorization": "Bearer your-api-key"
}
}
}
}变量 | 默认值 | 描述 |
|
| 监听端口 |
|
| 绑定地址 |
|
| MCP 端点路径 |
| API 密钥模式下必需 | |
| 设置以启用 OAuth 2.1 模式 |
GET /health → { "status": "ok", "transport": "streamable-http", "sessions": 3 }对于生产部署，如果您希望用户通过 Tacit 的登录流程进行身份验证，而不是管理 API 密钥：
TACIT_OAUTH_ISSUER=https://app.betacit.com npm run start:http这启用了：
动态客户端注册 — MCP 客户端自动注册
授权码 + PKCE — 用户通过 Tacit 的 Web UI 登录
令牌刷新 — 会话保持活动状态，无需重新认证
令牌撤销 — 清理会话终止
支持 OAuth 的 MCP 客户端（如 Claude Desktop）将通过 .well-known/oauth-authorization-server 元数据端点自动发现身份验证配置。
docker run -p 3001:3001 -e TACIT_API_KEY=your-api-key tacit/mcp-server使用上述 HTTP 传输配置进行连接。
连接后，您可以询问 AI 助手如下内容：
"List all my building sites"
"What AHUs are in Tower West?"
"Show me temperature sensors on AHU-001"
"Get the last 24 hours of supply air temperature data"
"What equipment feeds the lobby zone?"
变量 | 必需 | 默认值 | 描述 |
| 是 (stdio/HTTP) | 您的 Tacit API 密钥 | |
| 否 |
| API 基础 URL（用于自托管部署） |
| 否 | OAuth 发行者 URL（启用 OAuth 2.1 模式） | |
| 否 |
| HTTP 服务器端口 |
| 否 |
| HTTP 服务器绑定地址 |
| 否 |
| HTTP MCP 端点路径 |
npm run dev # watch mode — stdio transport
npm run dev:http # watch mode — HTTP transport
npm run build # compile TypeScript
npm start # run stdio transport
npm run start:http # run HTTP transportMIT
Execute a GraphQL query against the Tacit building digital twin API.
Compose any query using the Brick-compliant schema. Supports nested fields, filtering by Brick class, supply chain traversal (upstream/downstream), and recursive location hierarchy.
Use tacit_list_sites first to get a valid site ID, then construct queries freely.
Args:
site_id (string, required): The site ID (injected as siteId into your query variables)
query (string, required): GraphQL query string
variables (string, optional): JSON-encoded variables object (siteId is auto-injected)
All root queries require siteId (get from tacit_list_sites).
building(siteId!, id, name, nameMatch) → [Building] equipment(siteId!, id, name, nameMatch, locationId, locationName, systemId, is, hasProperty, propertyValue) → [Equipment] point(siteId!, id, name, nameMatch, equipmentId, locationId, locationName, zoneId, systemId, is, equipmentIs, hasProperty, propertyValue) → [Point] zone(siteId!, id, name, nameMatch, locationId, is, hasProperty, propertyValue) → [Zone] system(siteId!, name, nameMatch, is, hasProperty, propertyValue) → [System] location(siteId!, locationId!) → Location entityByIfcId(siteId!, ifcId!) → KgEntity (union: Building | Location | Zone | System | Equipment)
Building { uri, id, name, type, ifcId, properties { name value unit } locations(name, nameMatch, is, recursive) → [Location] zones(name, nameMatch, is, recursive) → [Zone] systems(name, nameMatch, is, recursive) → [System] equipment(name, nameMatch, is, recursive) → [Equipment] points(name, nameMatch, is, recursive) → [Point] }
Equipment { uri, id, name, type, typeHierarchy, ifcId, properties { name value unit } points(name, nameMatch, is) → [Point] # sensors/actuators on this equipment parts(name, nameMatch, is) → [Equipment] # sub-components partOf → Equipment # parent equipment feeds(name, nameMatch, is) → [Equipment] # what this equipment feeds fedBy(name, nameMatch, is) → [Equipment] # what feeds this equipment upstream(maxDepth, medium, is) → [Equipment] # full upstream chain downstream(maxDepth, medium, is) → [Equipment] # full downstream chain location → Location systems → [System] }
Point { uri, id, name, type, typeHierarchy, unit, equipmentId, timeseriesId currentValue { value timestamp quality } # latest live reading (null if no data) properties { name value unit } equipment → Equipment location → Location }
Zone { uri, id, name, type, typeHierarchy, ifcId, properties { name value unit } points(name, nameMatch, is) → [Point] fedBy(name, nameMatch, is) → [Equipment] # equipment feeding this zone upstream(maxDepth, medium, is) → [Equipment] locations → [Location] }
System { uri, id, name, type, ifcId, properties { name value unit } equipment(name, nameMatch, is, recursive) → [Equipment] points(name, nameMatch, is, recursive) → [Point] }
Location { uri, id, name, type, ifcId, properties { name value unit } locations(name, nameMatch, is, recursive) → [Location] # child locations parent → Location equipment(name, nameMatch, is, recursive) → [Equipment] points(name, nameMatch, is, recursive) → [Point] zones → [Zone] }
NameMatch: CONTAINS | EXACT (default: CONTAINS)
"is" filters by Brick class: "AHU", "VAV", "FCU", "Temperature_Sensor", "HVAC_Zone", etc.
"recursive: true" traverses the full hierarchy (e.g. all equipment in a building, not just direct children)
"nameMatch: EXACT" for exact name match, CONTAINS for partial
"upstream/downstream" traces the feeds/fedBy supply chain (use maxDepth to limit)
"medium" on upstream/downstream filters by medium type (e.g. "HOT_WATER", "CHILLED_WATER", "AIR")
"hasProperty" + "propertyValue" filter entities by custom properties
"equipmentIs" on points filters by the Brick class of the parent equipment
{ equipment(siteId: "x", is: "AHU") { name type points { name type unit timeseriesId } } }
{ zone(siteId: "x", name: "Atrium") { name upstream(maxDepth: 3) { name type } } }
{ building(siteId: "x") { name locations(recursive: true) { name type equipment { name type } } } }
{ equipment(siteId: "x", name: "AHU-001") { name type parts { name type } feeds { name type } fedBy { name type } points { name type unit timeseriesId } } }
{ point(siteId: "x", is: "Temperature_Sensor") { name unit timeseriesId currentValue { value timestamp } equipment { name type } location { name } } }
{ point(siteId: "x", locationName: "Tower West", equipmentIs: "VAV") { name type unit timeseriesId equipment { name } } }
{ entityByIfcId(siteId: "x", ifcId: "3Zu5Bv0LOHrPC6") { ... on Equipment { name type points { name } } ... on Location { name type } } }
| Name | Required | Description | Default |
|---|---|---|---|
| site_id | Yes | Site ID from tacit_list_sites | |
| query | Yes | GraphQL query string | |
| variables | No | JSON-encoded variables (siteId is auto-injected) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true, covering safety and idempotency. The description adds valuable context about the API's Brick-compliant schema, query capabilities, and auto-injection of siteId into variables, which helps the agent understand the tool's behavior beyond 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 overly long and includes extensive schema documentation (e.g., root queries, types, enums, examples) that belongs in external documentation. While informative, it's not front-loaded and contains redundant details that could be streamlined for an agent-focused tool description.
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 complexity (GraphQL API with rich querying) and lack of output schema, the description provides comprehensive context including schema overview, filter guides, and examples. However, the excessive detail reduces focus on core agent guidance, though it compensates for missing 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?
Schema description coverage is 100%, so the schema already documents all parameters (site_id, query, variables). The description adds minimal extra semantics (e.g., 'siteId is auto-injected'), but most parameter details are covered by the schema, meeting the baseline for high coverage.
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 explicitly states the tool's purpose as 'Execute a GraphQL query against the Tacit building digital twin API' with specific capabilities like nested fields, filtering, and supply chain traversal. It clearly distinguishes from sibling tools like tacit_list_sites (which provides site IDs) and tacit_timeseries (which likely handles time-series data).
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 provides explicit guidance: 'Use tacit_list_sites first to get a valid site ID, then construct queries freely.' It clearly indicates a prerequisite (site ID from sibling tool) and when to use this tool (for GraphQL queries) versus alternatives (tacit_list_sites for IDs).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List documents and files associated with a site.
Returns metadata for files uploaded to a site: spec sheets, maintenance documents, BIM source files, 3D models, and knowledge graph data.
Useful for answering questions like "What documentation exists for this building?" or "Are there spec sheets for this equipment?"
Args:
site_id (string, required): The site ID (from tacit_list_sites)
category (string, optional): Filter by file type. One of: kg-csv, model-3d, bim-source, spec-sheet, maintenance, other
entity_uri (string, optional): Filter by associated entity URI (from GraphQL entity.uri field)
Returns: List of files with name, category, size, and upload date.
| Name | Required | Description | Default |
|---|---|---|---|
| site_id | Yes | Site ID from tacit_list_sites | |
| category | No | Filter by category: kg-csv, model-3d, bim-source, spec-sheet, maintenance, other | |
| entity_uri | No | Filter by entity URI |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover key behavioral traits (read-only, open-world, idempotent, non-destructive), so the bar is lower. The description adds valuable context by specifying what types of files are returned (e.g., BIM source files, 3D models) and the filtering capabilities, which helps the agent understand the tool's behavior beyond the annotations. No contradictions with annotations exist.
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 well-structured and front-loaded, starting with the core purpose, followed by return details, usage examples, and parameter/return summaries. Every sentence adds value without redundancy, and it efficiently covers necessary information in a compact format.
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 moderate complexity (list operation with filtering), rich annotations (covering safety and behavior), and 100% schema coverage, the description is complete enough. It explains the purpose, usage context, and return values (though no output schema exists), providing sufficient information for an agent to use the tool effectively without overloading with redundant 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 description coverage is 100%, so the schema already fully documents all parameters. The description adds minimal value beyond the schema—it mentions filtering by category and entity_uri but doesn't provide additional semantic context. With high schema coverage, the baseline score of 3 is appropriate as the description doesn't significantly enhance parameter understanding.
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's purpose with specific verbs ('List documents and files') and resources ('associated with a site'), distinguishing it from siblings like tacit_list_sites (which lists sites) and tacit_graphql (which performs GraphQL queries). It explicitly mentions the types of files returned (spec sheets, maintenance documents, etc.), making the scope unambiguous.
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 provides explicit usage guidance with examples of when to use it ('Useful for answering questions like...'), mentions a prerequisite (site_id 'from tacit_list_sites'), and implicitly distinguishes it from siblings by focusing on file listing rather than site listing, GraphQL queries, or timeseries data. This gives clear context for when this tool is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all building sites the current API key has access to.
Each site represents a physical location (building, campus, warehouse) managed in Tacit. Sites are the top-level container. You need a site ID to query buildings, equipment, points, zones, and systems.
Returns: Array of sites with id, name, address, city, country, timezone.
Use this tool first to discover available sites before querying building data.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover read-only, open-world, idempotent, and non-destructive traits, so the bar is lower. The description adds valuable context by explaining that sites are 'top-level containers' needed for querying other data (buildings, equipment, etc.), which aids in understanding dependencies and workflow, though it doesn't detail rate limits or auth specifics beyond API key access.
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, followed by explanatory context and usage guidance in four concise sentences. Each sentence adds value: defining sites, their role, return format, and when to use the tool, with no wasted words.
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 (0 parameters, no output schema) and rich annotations, the description is complete. It explains what the tool does, its importance in the workflow, and the return format, providing all necessary context for an agent to use it effectively without over-explaining.
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?
With 0 parameters and 100% schema description coverage, the baseline is high. The description adds no parameter-specific information (as there are none), but it clarifies the tool's scope ('all building sites the current API key has access to'), which implicitly defines the input context, earning a score above the minimum.
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 action ('List all building sites') and resource ('sites'), distinguishing it from siblings like tacit_list_files (files) and tacit_timeseries (timeseries data). It specifies that sites are 'top-level containers' for physical locations, making the purpose specific and well-defined.
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 explicitly provides usage guidance: 'Use this tool first to discover available sites before querying building data.' This indicates when to use it (as an initial discovery step) and implies alternatives (other tools for building data), offering clear context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Query historical or live sensor data for one or more points.
Points are identified by their timeseriesId (UUID). Use tacit_graphql first to find points and their timeseriesId values.
Args:
site_id (string, required): The site ID
point_ids (string, required): Comma-separated timeseriesId UUIDs (max 200)
start (string, optional): Start time, relative like "-1h", "-24h", "-7d" or ISO 8601. Default: "-1h"
end (string, optional): End time, "now()" or ISO 8601. Default: "now()"
window (string, optional): Aggregation window like "5m", "1h", "1d". Only with aggregate.
aggregate (string, optional): Aggregation function: mean, min, max, sum, count, first, last. Default: "mean"
limit (number, optional): Max records per point (1-10000). Default: 1000
Common patterns:
Last hour raw: start="-1h" (default)
Daily averages for a week: start="-7d", window="1d", aggregate="mean"
Last 24h at 15-min intervals: start="-24h", window="15m"
For current/live values, use tacit_graphql with the currentValue { value timestamp quality } field on Point instead of this tool.
Returns: Array of series, each with timeseriesId, name, type, unit, equipment, and data records [{t, v}].
| Name | Required | Description | Default |
|---|---|---|---|
| site_id | Yes | Site ID | |
| point_ids | Yes | Comma-separated timeseriesId UUIDs (from tacit_graphql Point.timeseriesId) | |
| start | No | Start time: "-1h", "-24h", "-7d", or ISO 8601 | |
| end | No | End time: "now()" or ISO 8601. Default: "now()" | |
| window | No | Aggregation window: "5m", "1h", "1d" | |
| aggregate | No | Aggregation: mean, min, max, sum, count, first, last | |
| limit | No | Max records per point (1-10000) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering safety and idempotency. The description adds valuable context beyond this: it explains that points are identified by UUIDs, mentions the max limit of 200 point IDs, provides common usage patterns with examples, and describes the return format. While it doesn't detail rate limits or auth needs, it enriches the behavioral understanding significantly.
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 well-structured and front-loaded with the core purpose. It efficiently uses bullet points for parameters and common patterns, avoiding redundancy. Every sentence adds value, such as clarifying sibling tool relationships and providing usage examples, with no wasted words.
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 complexity (7 parameters, 2 required) and rich annotations, the description is highly complete. It covers purpose, usage guidelines, parameter details, behavioral context, and return values. Although there's no output schema, the description specifies the return format ('Array of series, each with timeseriesId, name, type, unit, equipment, and data records [{t, v}]'), filling that gap effectively.
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?
With 100% schema description coverage, the baseline is 3. The description adds meaningful semantics: it clarifies that point_ids are 'comma-separated timeseriesId UUIDs (max 200)', provides default values for optional parameters (e.g., start: '-1h', end: 'now()', aggregate: 'mean'), and gives practical examples like 'Last hour raw: start="-1h" (default)'. This enhances understanding beyond the schema's basic descriptions.
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's purpose: 'Query historical or live sensor data for one or more points.' It specifies the resource (sensor data/points), the action (query), and distinguishes it from sibling tools by mentioning that point IDs come from 'tacit_graphql' and that for current/live values, 'tacit_graphql' should be used instead. This provides specific verb+resource differentiation.
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 provides explicit guidance on when to use this tool versus alternatives. It states: 'Use tacit_graphql first to find points and their timeseriesId values' and 'For current/live values, use tacit_graphql with the currentValue { value timestamp quality } field on Point instead of this tool.' This clearly defines prerequisites and exclusions, helping the agent choose correctly.
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.1.0tacit_graphqltacit_list_filestacit_list_sitestacit_timeseriesScored across 4 tools
Each tool has a distinct and non-overlapping purpose: tacit_list_sites lists sites, tacit_graphql queries building data, tacit_timeseries retrieves sensor data, and tacit_list_files lists documents. The descriptions clearly differentiate their functions, with no ambiguity in tool selection.
All tool names follow a consistent 'tactic_' prefix with descriptive snake_case suffixes (e.g., tacit_list_sites, tacit_graphql). This pattern is uniform across all four tools, making them predictable and easy to identify.
With 4 tools, the server is well-scoped for its purpose of interacting with building digital twin data. Each tool serves a critical role: site discovery, data querying, timeseries retrieval, and file listing, providing a complete workflow without unnecessary complexity.
The tool set covers core operations for building data access: listing sites, querying entities, retrieving timeseries, and listing files. Minor gaps exist, such as no explicit tools for creating or updating data, but the GraphQL tool allows flexible queries that can handle many needs, making it reasonably complete for query-focused workflows.
Connects AI assistants to QCDatabase.AI for everyday construction quality-control work.
Connects AI assistants to TrackingTime for querying time entries, projects, tasks, customers, and team data using natural language.
Search, read, and automate TextMine documents, records, workflows, integrations, and agent tasks.
Company brain for AI agents — temporal knowledge graph search, exploration, and durable memory.
