Provides a tool to query the building knowledge graph through a Brick-compliant GraphQL interface, allowing AI assistants to compose queries about building sites, equipment, sensors, and zones.
Click on "Install 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., "@Tacit MCP Show me all temperature sensors for AHU-01 in Tower West"
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.
MCP server that connects AI assistants to Tacit building digital twins. Ask questions about your buildings, equipment, sensors, and zones in natural language.
Works with Claude Desktop, Claude Code, Cursor, Windsurf, and any MCP-compatible client.
Four read-only tools:
Tool | Purpose |
| List buildings your API key can access |
| Query the building knowledge graph (Brick-compliant) |
| Fetch historical sensor data |
| List documents and files for a site |
The GraphQL tool includes the full schema reference, so the AI model can compose queries without needing separate documentation.
Related MCP server: skyspark-mcp
npx -y @tacit/mcp-serverJust point your MCP client at it (see configuration below). No cloning, no building.
git clone https://github.com/ucl-sbde/tacit-mcp.git
cd tacit-mcp
npm install
npm run buildYou'll need a Tacit API key. Get one from your dashboard at app.betacit.com under Site Settings > API Keys.
The standard method — the MCP client launches the server as a child process. Best for individual use on your own machine.
Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": {
"tacit": {
"command": "npx",
"args": ["-y", "@tacit/mcp-server"],
"env": {
"TACIT_API_KEY": "your-api-key"
}
}
}
}Add to .mcp.json in your project:
{
"mcpServers": {
"tacit": {
"command": "npx",
"args": ["-y", "@tacit/mcp-server"],
"env": {
"TACIT_API_KEY": "your-api-key"
}
}
}
}Add to .cursor/mcp.json:
{
"mcpServers": {
"tacit": {
"command": "npx",
"args": ["-y", "@tacit/mcp-server"],
"env": {
"TACIT_API_KEY": "your-api-key"
}
}
}
}Run the server as a persistent HTTP service. Best for teams, cloud deployments, and environments where users can't install Node.js locally.
# 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-httpThe server listens on http://0.0.0.0:3001/mcp by default.
Point your client at the server URL with a bearer token:
{
"mcpServers": {
"tacit": {
"type": "streamable-http",
"url": "https://your-host:3001/mcp",
"headers": {
"Authorization": "Bearer your-api-key"
}
}
}
}Variable | Default | Description |
|
| Port to listen on |
|
| Bind address |
|
| MCP endpoint path |
| Required in API key mode | |
| Set to enable OAuth 2.1 mode |
GET /health → { "status": "ok", "transport": "streamable-http", "sessions": 3 }For production deployments where you want users to authenticate via Tacit's login flow instead of managing API keys:
TACIT_OAUTH_ISSUER=https://app.betacit.com npm run start:httpThis enables:
Dynamic client registration — MCP clients register automatically
Authorization code + PKCE — users log in through Tacit's web UI
Token refresh — sessions stay alive without re-authentication
Token revocation — clean session termination
MCP clients that support OAuth (like Claude Desktop) will discover the auth configuration automatically via the .well-known/oauth-authorization-server metadata endpoint.
docker run -p 3001:3001 -e TACIT_API_KEY=your-api-key tacit/mcp-serverConnect using the HTTP transport config above.
Once connected, ask your AI assistant things like:
"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?"
Variable | Required | Default | Description |
| Yes (stdio/HTTP) | Your Tacit API key | |
| No |
| API base URL (for self-hosted deployments) |
| No | OAuth issuer URL (enables OAuth 2.1 mode) | |
| No |
| HTTP server port |
| No |
| HTTP server bind address |
| No |
| HTTP MCP endpoint path |
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.
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.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Connects AI assistants to QCDatabase.AI for everyday construction quality-control work.
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.
Provide real-time data querying and visualization by integrating Tako with your agents. Generate o…
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/ucl-sbde/tacit-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
