MCP-Server, der KI-Assistenten mit digitalen Zwillingen von Tacit verbindet. Stellen Sie Fragen zu Ihren Gebäuden, Anlagen, Sensoren und Zonen in natürlicher Sprache.
Funktioniert mit Claude Desktop, Claude Code, Cursor, Windsurf und jedem MCP-kompatiblen Client.
Vier schreibgeschützte Werkzeuge:
Werkzeug | Zweck |
| Listet Gebäude auf, auf die Ihr API-Schlüssel zugreifen kann |
| Fragt den Wissensgraphen des Gebäudes ab (Brick-konform) |
| Ruft historische Sensordaten ab |
| Listet Dokumente und Dateien für einen Standort auf |
Das GraphQL-Tool enthält die vollständige Schema-Referenz, sodass das KI-Modell Abfragen erstellen kann, ohne dass eine separate Dokumentation erforderlich ist.
Related MCP server: skyspark-mcp
npx -y @tacit/mcp-serverVerweisen Sie einfach Ihren MCP-Client darauf (siehe Konfiguration unten). Kein Klonen, kein Build-Prozess.
git clone https://github.com/ucl-sbde/tacit-mcp.git
cd tacit-mcp
npm install
npm run buildSie benötigen einen Tacit-API-Schlüssel. Diesen erhalten Sie in Ihrem Dashboard unter app.betacit.com unter Site Settings > API Keys.
Die Standardmethode — der MCP-Client startet den Server als untergeordneten Prozess. Am besten für die individuelle Nutzung auf Ihrem eigenen Rechner geeignet.
Bearbeiten Sie ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) oder %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": {
"tacit": {
"command": "npx",
"args": ["-y", "@tacit/mcp-server"],
"env": {
"TACIT_API_KEY": "your-api-key"
}
}
}
}Fügen Sie dies zu .mcp.json in Ihrem Projekt hinzu:
{
"mcpServers": {
"tacit": {
"command": "npx",
"args": ["-y", "@tacit/mcp-server"],
"env": {
"TACIT_API_KEY": "your-api-key"
}
}
}
}Fügen Sie dies zu .cursor/mcp.json hinzu:
{
"mcpServers": {
"tacit": {
"command": "npx",
"args": ["-y", "@tacit/mcp-server"],
"env": {
"TACIT_API_KEY": "your-api-key"
}
}
}
}Führen Sie den Server als persistenten HTTP-Dienst aus. Am besten für Teams, Cloud-Bereitstellungen und Umgebungen geeignet, in denen Benutzer Node.js nicht lokal installieren können.
# 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-httpDer Server lauscht standardmäßig auf http://0.0.0.0:3001/mcp.
Verweisen Sie Ihren Client mit einem Bearer-Token auf die Server-URL:
{
"mcpServers": {
"tacit": {
"type": "streamable-http",
"url": "https://your-host:3001/mcp",
"headers": {
"Authorization": "Bearer your-api-key"
}
}
}
}Variable | Standard | Beschreibung |
|
| Port, auf dem gelauscht werden soll |
|
| Bind-Adresse |
|
| Pfad des MCP-Endpunkts |
| Erforderlich im API-Schlüssel-Modus | |
| Festlegen, um den OAuth 2.1-Modus zu aktivieren |
GET /health → { "status": "ok", "transport": "streamable-http", "sessions": 3 }Für Produktionsbereitstellungen, bei denen sich Benutzer über den Anmeldeablauf von Tacit authentifizieren sollen, anstatt API-Schlüssel zu verwalten:
TACIT_OAUTH_ISSUER=https://app.betacit.com npm run start:httpDies ermöglicht:
Dynamische Client-Registrierung — MCP-Clients registrieren sich automatisch
Autorisierungscode + PKCE — Benutzer melden sich über die Web-Benutzeroberfläche von Tacit an
Token-Aktualisierung — Sitzungen bleiben ohne erneute Authentifizierung aktiv
Token-Widerruf — saubere Beendigung der Sitzung
MCP-Clients, die OAuth unterstützen (wie Claude Desktop), erkennen die Authentifizierungskonfiguration automatisch über den Metadaten-Endpunkt .well-known/oauth-authorization-server.
docker run -p 3001:3001 -e TACIT_API_KEY=your-api-key tacit/mcp-serverVerbinden Sie sich unter Verwendung der oben genannten HTTP-Transportkonfiguration.
Sobald die Verbindung hergestellt ist, können Sie Ihren KI-Assistenten Dinge fragen wie:
"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 | Erforderlich | Standard | Beschreibung |
| Ja (stdio/HTTP) | Ihr Tacit-API-Schlüssel | |
| Nein |
| API-Basis-URL (für selbst gehostete Bereitstellungen) |
| Nein | OAuth-Issuer-URL (aktiviert den OAuth 2.1-Modus) | |
| Nein |
| HTTP-Server-Port |
| Nein |
| HTTP-Server-Bind-Adresse |
| Nein |
| HTTP-MCP-Endpunktpfad |
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.
