FAQ

Frequently Asked Questions


Free 60-Day Trial

Sign up free and get the full platform for 60 days — no credit card required. Or skip the signup and explore a live sandbox organization with real data in seconds.

START 60-DAY TRIAL TRY A SANDBOX



Answers

What is Temporal Intelligence?

Temporal intelligence is the ability to store, query, and reason across the complete history of every value and every relationship in your data — not just the current state. It means every data point knows when it happened, every relationship knows when it changed, and every query can travel through time.

Traditional databases store the current state and discard what came before. A temporal intelligence platform preserves the full history natively — every cell in the relational model holds up to 100 million timestamped values, not just one — so any query can reach any point in time, and AI agents, analysts, and automated systems can reason over years of context without pre-aggregation. One primitive — the stream — replaces the history tables, triggers, materialized views, batch roll-up jobs, and junction tables that most approaches require you to build from scratch.

What is GroveStreams?

GroveStreams is a temporal intelligence platform with built-in analytics, forecasting, and an AI query layer. It replaces the historian, relational database, analytics engine, dashboards, and ML pipeline that most teams stitch together — with one platform and one query language.

The volume and granularity of data organizations generate keeps growing, and traditional stacks make engineers rebuild the same temporal scaffolding — history tables, triggers, materialized views, batch roll-up jobs, junction tables — from scratch for every project. GroveStreams collapses that scaffolding into a single primitive: the stream. Every property on every entity, and every relationship between entities, is a stream with its own independent time axis.

The result: humans, applications, and AI agents query the complete history through a single platform-independent open API — and react to changes as they happen.

 

GroveStreams specializes in:

  • Drag-and-drop HTML dashboards — embeddable widgets, mobile-responsive, public or private.
  • Automatic registration — components and streams register themselves on first feed and flow into existing dashboards and roll-ups.
  • Events & alerts — configurable templates for email, SMS, MMS, and HTTP webhook notifications.
  • Location tracking — latitude, longitude, elevation, and heading are first-class streams (Mapbox integration for visualization).
  • Role-based access security enforced at the query layer — not at an API gateway, not in application code.
  • Public/private organizations — restrict to your users or allow anonymous guest access with configurable rights.
  • HTTP REST API — nearly the entire platform is exposed via API, with fine-grained access security.
  • Time-of-use filtering, time zone support, and custom units & formatting.
  • 100% thin-client browser UI — no plug-ins, no desktop installs.
  • Compatible with Tableau, Power BI Desktop, DBeaver, Grafana, and Excel via our ODBC/JDBC adapter (Beta) — connect with any standard PostgreSQL driver. Saved GS SQL queries appear as VIEWs, so BI tools get full time-series access, not just current values. Also supports OData for Power BI Report Builder, SAP, and IBM Cognos.


    • Who would use GroveStreams?

    Any team that needs to capture data, track how it changes over time, query the full history, and act on it quickly — whether that's one stream or millions. Typical users include:

    Use GroveStreams when you need to:



    What is meant by high performance and near real-time?

    GroveStreams runs across a cluster that partitions data and processes feeds in parallel. Most transactions complete within milliseconds, and a typical request to download one day of second-interval samples (86,400 values) returns in under a second. The API also batches samples across streams and components, so many streams can be uploaded together with sub-second response times.

    As feeds arrive, GroveStreams runs the full pipeline inline: roll-up calculations, gap filling, constraint checks, derivations, location updates, event detection, and notifications. Long-running operations — like a template reconcile after a schema change — are handled by an asynchronous job framework, so feeds keep flowing while the job completes in the background.



    Do I need to buy or lease servers?

    No. Data from one or more sources can be uploaded directly into GroveStreams as long as the source has Internet access. The option to lease an entire private cluster is available to large customers.



    How am I billed?

    The platform is free during the trial period. Paid plans (Growth, Business, Enterprise, Strategic) are billed monthly by credit card; Enterprise customers may request monthly invoicing.

    Plan caps on components, samples, organizations, and users vary by tier — from limited on the free trial to unlimited on Enterprise and Strategic. See the pricing page and the pricing FAQ for current limits.



    Is GroveStreams secure?

    Yes. Our data center is SOC2 certified. The GroveStreams website is password protected and allows for all requests to occur via SSL. Strong passwords, that expire, can be configured along with two factor authentication (2FA).

    Security is enforced at the query layer. When users interact through the UI, GS SQL, the AI assistant, ODBC/JDBC connections, or OAuth-authenticated OData connections, role-based access control is enforced inside the query engine itself. If a user doesn't have read access to a component, that component's data is absent from query results entirely — not just hidden in the UI.

    Dashboards are security-aware. The same dashboard viewed by two different users will show different sets of components based on each user's access rights. An operations manager sees their region's data; a field technician sees only their assigned equipment — same dashboard, same URL, different data.

    API keys provide a separate security model for system-to-system integration, scoped by endpoint, resource type, IP address, and domain whitelist. Specific rights can be assigned per resource type or per resource instance. See the Developers page for details.



    How does data get into GroveStreams?

    Data lands through the Temporal Wire (TW) ingestion layer, which accepts feeds via:



    What are TW, TDQ™, and TEQ™?

    GroveStreams exposes three API layers, each addressing a different stage of the data lifecycle:

    TDQ and TEQ share the same grammar, functions, and operators — they differ only in how tables and columns are resolved. Together with TW, they form a complete pipeline: ingest with TW, query internals with TDQ, query your semantic model with TEQ.



    What are Components and Streams?

    A stream is a time-ordered series of data points. Each data point carries either a single timestamp or a time range, with millisecond precision. Streams come in three types:

    Stream values can be numeric, datetime, text, boolean, geo coordinate (latitude, longitude, elevation), or file blobs. Each stream can have time filters, constraints, gap-filling rules, units, and formatting applied on the way in. Data lands via the API or is computed as a derived stream. Streams on a single component don't need to upload together — the only exception is mobile components, which upload latitude and longitude in a single feed.

    A component is a container for streams and events that share a context. For example, an energy meter might have streams for voltage, current, and power; a customer account might have streams for balance, credit limit, and risk tier. Components can be physical assets or logical entities — the data model is the same.



    What's a Derived Stream?

    A derived stream computes its values from other streams — expressions, aggregations, or external feeds — and updates automatically as source data changes.

    From an expression. Reference any other streams in the organization in an Excel-style formula. Calculations run as new data arrives, or periodically (every one to three minutes) for large batch derivations. The engine resolves time alignment, windowing, and rollups automatically — variables with different base cycles or interval offsets compose inside a single expression without manual window management.

    From an aggregation. Roll up two or thousands of streams in one definition — sums, averages, mins, maxes, gap counts, and more for each interval in the aggregation window. Aggregations can run on demand or on a schedule.

    From an RSS feed. Internal or external RSS feeds (weather services, market data, exchange rates, third-party APIs that publish RSS) can drive a stream directly, with a simple filter to extract the values you need. RSS-derived streams refresh hourly.

    Derived streams are just like other streams except that their feed data is derived by the GroveStreams derivation engine. They can be graphed, monitored in dashboards, and used as dependents in other derived streams, creating computation graphs of any depth.

    Retroactive change propagation. Correct a historical sample — or backfill a gap — and every dependent rollup, derived stream, and FK-resolved calculation downstream recomputes automatically. No batch jobs to re-run, no orchestration to manage. The same machinery that runs derivations forward also runs them backward when the past changes.

    FK-Resolved Dependencies (Cross-Entity Derivation):
    Expression variables can optionally include a Resolution SQL statement that dynamically resolves which stream to use at derivation time. This enables temporal relationship resolution — when the relationship between entities changes over time, the derivation engine automatically detects the change points, splits the derivation range into segments (one per stable relationship period), and derives each segment using the correct target entity's data.

    For example, an energy meter connected to Customer_A from January through June, then moved to Customer_B in July, will derive the first half of the year using Customer_A's rate data and the second half using Customer_B's rate data — automatically. Multi-hop chains are supported (e.g., meter → customer → supplier), with the engine walking each hop and detecting relationship changes at every level.

    We're not aware of another platform that does this declaratively. On the platforms we've evaluated — time-series databases, stream processors, cloud data warehouses, and traditional RDBMS setups — handling relationship changes during a calculation requires custom pipeline code to detect change points, split time ranges, re-resolve targets, and stitch results. In GroveStreams, it's a single SQL expression on the variable definition. See our Derived Streams guide for full details and comparisons.

    Expression variables are streams. If a variable is an interval stream, then the user can choose the interval offset for that variable. For example, if an hourly interval with a time span of 2:00 pm to 3:00 pm is being calculated, a dependent variable's offset can be set to -1 and that variable's data for time span 1:00 pm to 2:00 pm will be used in the calculation. Offsets are useful for things like calculating rolling averages or comparing monthly costs.

    Expressions can contain any stream data types, conditional "if" operators (<=,>=, <,>, !=, ==, &&, ||) and many functions (trig, log, exponents, absolute value, statistical, string, JSON, time formatting, and more).

    Example of a derived stream expression that calculates one second 3 point rolling averages from component1.stream1:

    Variables:

    Variable Offset Stream Cycle Cycle Function
    n 0 component1.stream1 Second -
    n_minus_1 -1 component1.stream1 Second -
    n_minus_2 -2 component1.stream1 Second -

    Expression:
    (n + n_minus_1 + n_minus_2) / 3

    Example of a derived stream expression with an FK-resolved dependency that calculates energy cost using the current customer's rate — automatically following customer reassignments over time:

    Variables:

    Variable Stream Resolution SQL Cycle Function
    kwh meter1.energy - Hour SUM
    rate - SELECT customerUid, 'rate' FROM meter WHERE cuid = @cuid - -

    Expression:
    kwh * rate

    If the meter was connected to Customer_A (rate = $0.12/kWh) from January through June, then reassigned to Customer_B (rate = $0.15/kWh) in July, the derivation engine automatically uses $0.12 for Jan–Jun and $0.15 for Jul–Dec. No custom code required.

    Other usages of Derived Streams:

    Derived stream variables can be different data types. A stream defined as text can be derived from the sum of two other streams of types long and double. GroveStreams will attempt to do the data type conversion wherever it is possible. If the conversion is not possible, the resulting interval will be considered a Gap or NULL.

    For full details on derived streams — including temporal relationship resolution, comparison with other platforms, derivation triggers, and performance characteristics — see the Derived Streams guide.



    What are FK-Resolved Dependencies?

    FK-resolved dependencies enable temporal relationship resolution inside the derivation engine — a capability we're not aware of any other platform offering declaratively. In the real world, relationships between entities change over time — meters move between customers, sensors are reassigned between production lines, instruments transfer between trading desks. When you derive a stream that depends on a related entity's data, you need the correct related entity for each point in time.

    With FK-resolved dependencies, instead of pointing a variable directly at a fixed stream, you provide a Resolution SQL statement. The derivation engine parses this SQL, follows the foreign key chain through your data model, loads the FK stream history to detect when relationships changed, and automatically splits the derivation into segments — one per stable relationship period. Each segment is derived with the correct target entity's data, and the results are stitched together automatically.

    For example, if a meter's customerUid stream shows it was connected to Customer_A from January through June, then Customer_B from July onward, a cost derivation (kwh * rate) automatically uses Customer_A's rate for Jan–Jun and Customer_B's rate for Jul–Dec. Multi-hop chains are supported (e.g., meter → customer → supplier), with the engine detecting relationship changes at every level and producing the correct segments.

    We're not aware of another platform that does this natively. On the platforms we've evaluated — time-series databases, stream processors, cloud data warehouses, and traditional RDBMS setups — handling relationship changes during a calculation requires custom pipeline code to detect change points, split time ranges, re-resolve targets, and stitch results. In GroveStreams, it's a single SQL expression on the variable definition. See the FK-Resolved Dependencies section of the Derived Streams guide for full details.



    What's a Component Template?

    Large organizations typically have a large number of entities that are identical (such as utility electric meters). It makes no sense to manually create a new component instance by hand every time a new entity comes on-line.

    A component template is used to simplify creating multiple component instances that only differ by a few attributes and stream feed data. When a component uses the feed API to upload data it can pass in a component template Id. A component instance will be created automatically within the organization, if a component does not already exist for that feed (also known as automatic registration).

    One or more components created from a component template can remain linked to that template. Any changes made to a template can be applied to all components linked to it. This makes mass modeling changes easy to do without any required programming.

    Live schema evolution: When you modify a template — add a stream, remove a stream, change a data type — GroveStreams automatically reconciles every linked component. This runs in the background with zero downtime: queries continue to return results and data continues flowing into streams throughout the process. Internally, changes are reconciled into a temporary stream. Once complete, the component is briefly locked, any new data that arrived during reconciliation is merged, and the temporary stream replaces the original. This means tens of thousands of components can be updated from a single template change while the platform stays fully operational.



    What is a GroveStreams Organization?

    An organization is a tenant workspace — the top-level container that owns its own components, streams, templates, dashboards, maps, security policies, and API access. Whoever creates an organization is its owner; other users join by invitation with the rights the owner grants. Every organization you own or belong to appears on your start page when you sign in.

    Data is stored hierarchically within each organization:

    Organization
        └ Components
            └ Streams
        └ Component templates
        └ Dashboards & maps



    How often can a feed be uploaded?

    Feeds can be uploaded every ten seconds or longer per source IP, with many streams batched into a single request. Sample frequency is independent of upload cadence — a stream that samples once per second can buffer ten samples and ship them every ten seconds in one feed. For exact rate limits, see the HTTP API Limits page.



    What are Cycles and Rollup Calendars?

    Cycle. A cycle is a recurring time interval. Every interval stream is anchored to a base cycle that defines its sample period. Cycles can be fixed or custom:

    Cycles can use a fixed time zone or inherit from each component — so the same cycle definition can roll up a multinational fleet to each location's local day, or align everyone to corporate-HQ time.

    Rollup calendar. A rollup calendar is an ordered list of cycles that defines how a stream aggregates upward — for example, seconds → 5 minutes → hour → day → month → year. Roll-ups are optional, but they're what makes high-frequency data tractable: a year of one-second samples is 31.5 million intervals, but the same year rolled up to hourly is 8,760. You can dashboard any cycle and watch it update in real time as base-cycle data arrives.

    Roll-ups are computed automatically as feeds land — no batch jobs, no Spark pipelines. Only the base cycle is written via the API; every cycle above it is derived. Edit a historical value and every dependent rollup recalculates.

    Rollup statistics available on any cycle:

    Gap intervals are skipped by first, last, min, max, avg, and the occurrence statistics on interval streams.

    A base cycle doesn't have to appear in the rollup calendar itself — it just has to fit evenly into one of the cycles in the calendar, and the rollup starts from there. A 30-minute base cycle, for example, rolls up cleanly into hour → day → month → year. A 7-second cycle won't fit into an 8-second or 1-minute rollup, but will fit into a 42-second one.



    Do you have time zone support?

    Yes. Every component carries a time zone. Every cycle either fixes its own time zone or inherits from the component — so a single cycle definition can drive multi-region rollups against either a corporate-HQ day or each location's local day.

    Rollups use the cycle's time zone and reference date to convert interval boundaries to UTC; data exchanged through the API is always UTC epoch milliseconds.

    A multinational operator with assets across regions can roll daily production up to each asset's local-day boundary, headquarters-day boundary, or both — just by choosing the time-zone reference on the rollup cycle.



    Do you support location tracking?

    Yes. Latitude, longitude, elevation, and heading are first-class streams — not a separate spatial subsystem. Any component can carry fixed coordinates as attributes, or store position as regular, interval, or point streams that update over time. Everything you can do to a numeric stream — derive it, roll it up, correlate it — you can do to a location stream.

    Map views show each component's current position alongside its active events. Vehicles, fleet assets, mobile sensors, shipments, and field personnel can all be tracked — and their location correlated against any other stream in the same query.



    How are Time Filters used?

    A time filter restricts data to specific time windows — seasons, days of the week, or hours within a day. Applied on ingest or in derivations, samples outside the filter are converted to gaps (for interval streams) or skipped (for regular streams).

    Common uses: extracting time-of-use billing determinants, isolating peak-demand windows, scoping anomaly detection to business hours, or measuring shift-level performance.



    What is the AI Assistant and what can it do?

    The GroveStreams AI Assistant is an agentic system with access to over 35 built-in tools. You pick from a curated set of LLM profiles spanning OpenAI, Anthropic, Gemini, and xAI — your organization admin controls which profiles are available to your users and which one serves as the org default — and the assistant autonomously reasons about your requests, executes tools, and returns final answers. It is available within the GroveStreams web application and as an HTTP API for integration with external applications and AI agents.

    Key capabilities:

    The assistant retains context across a conversation, so you can ask follow-up questions without repeating yourself. All tool calls run under your user security context — the assistant can only access and query objects you have permissions for.

    Brain and Minion tiers. Each LLM profile pairs two models: a Brain for the main reasoning loop and a Minion for lightweight delegated work like documentation search and query rewriting. The Minion is typically a cheaper, faster model paired with a more capable Brain (e.g., GPT‑5‑nano with GPT‑5, or Claude Haiku with Claude Sonnet) so main-loop quality stays high while routine sub-agent work stays inexpensive. Brain and Minion bill at their own per-token multipliers. See the AI Assistant page for which sub-agents run at which tier.

    Per-model multipliers track third-party LLM provider pricing in good faith but may lag behind vendor price changes — sometimes by hours, sometimes by weeks. Multipliers may be revised at any time without notice and revisions are not retroactive. AI Assistant credit charges are final once metered and are not refundable based on multiplier lag. See Terms of Service Section 10.8 for the full disclosure.

    For a deep dive into how the AI Assistant works, see the AI Assistant page.



    Can I manage my schema through GS SQL?

    Yes. GS SQL includes full DDL (Data Definition Language) support. You can CREATE, ALTER, and DROP over 15 entity types — templates (tables), cycles, rollup calendars, stream groups, time filters, units, catalogs, delete profiles, runnables, connections, JDBC imports, views, materialized views, dashboards, and entity diagrams. Every DDL statement supports IF [NOT] EXISTS and FOLDER_PATH for organizational placement.

    Templates support typed columns with REFERENCES for foreign keys, DERIVED AS for formula-based streams, and configurable rollup methods. Use RECONCILE NOW after altering a template to propagate changes to every linked component with zero downtime — queries keep working and data keeps flowing throughout the process.

    Views let you save any GS SQL query as a first-class object that BI tools, the AI assistant, and other queries can reference as a table. Views can be internal (over your GroveStreams data) or external via CREATE VIEW … CONNECTION (live JDBC to PostgreSQL, MySQL, and other relational sources). Either form can be materialized for caching or evaluated live on every reference, and all of them surface through the ODBC/JDBC adapter.

    Entity diagrams are DDL-managed visual layouts of your templates, views, and the foreign-key relationships between them — defined with PLACE NODE, PLACE VIEW, and RELATIONSHIP statements. Diagrams are shared across your organization and managed entirely through DDL, so the schema and its picture stay in sync.

    Catalogs provide a Snowflake-style namespace layer for grouping templates, views, and related objects — useful for isolating tenants, projects, or environments within a single organization.

    The AI Assistant can execute DDL too, so you can describe a data model in natural language and the assistant generates and runs the statements to build it — templates, foreign keys, rollup calendars, derived streams, views, dashboards, and entity diagrams included. For the full reference, see the GS SQL DDL documentation.



    What is MCP and how do I use it with GroveStreams? (Beta)

    MCP support is currently in beta. MCP — the Model Context Protocol — is a standard interface that lets external AI agents (Claude Desktop, Claude Code, Cursor, ChatGPT Desktop, and any MCP-compatible client) connect to GroveStreams natively. The agent gets four tools: describe_org for orientation, run_gsql for direct GS SQL execution, ask_grovestreams for natural-language delegation to the GroveStreams AI Assistant, and send_samples for Temporal Wire ingestion. It also gets read-only access to your help docs and per-org templates / dashboards / saved queries via MCP Resources, so it grounds itself on real GroveStreams content instead of hallucinating syntax. Authentication is per-user via OAuth 2.1 with PKCE. Full details: developers/mcp.html.



    How is MCP different from the ODBC/JDBC adapter?

    ODBC and MCP solve different problems and most teams use both. ODBC is your application's data driver — the runtime path your BI tool, dashboard, or app code uses to read and write GroveStreams data. Same engine, same RBAC, different transport. MCP is your AI's GroveStreams partner — the development-time path your AI agent uses to design schemas, author queries, build dashboards, and troubleshoot derivations. ODBC for your app, MCP for your AI.



    Does MCP require a separate subscription?

    No. MCP uses the existing LLM token infrastructure for ask_grovestreams calls and the standard query metering for run_gsql and send_samples. MCP usage is shown as a separate line item on your billing page so you can see exactly what your AI integrations cost. A per-session token budget (default 1,000,000 tokens) acts as a runaway guard.



    Which AI clients work with GroveStreams MCP?

    Any client implementing MCP spec 2025-11-25 over Streamable HTTP with OAuth 2.1 + PKCE. That includes Claude Desktop, Claude Code, Cursor, ChatGPT Desktop, and a growing list of community clients. The MCP developer reference has copy-paste config snippets for the major clients.



    Can my organization disable MCP?

    Yes. MCP is off by default. Owners and admins enable it from the AI Assistant & MCP tab in Organization Settings: a master toggle, per-tool exposure checkboxes (run_gsql / ask_grovestreams / send_samples), and an MCP SQL Policy that fences what SQL agents are allowed to run. The MCP SQL Policy applies to all SQL routed through MCP — including SQL the AI Assistant runs internally during ask_grovestreams — so admins can safely expose the assistant without worrying that an external agent could smuggle DDL or DML through it.



    How much functionality is exposed in the GroveStreams HTTP REST API?

    Nearly all of it. The web UI consumes the same public API for every non-static request — so anything the application does, your code can do too. A quick way to learn the API is to open your browser's developer tools network panel while using the platform and watch the requests fly by.

    You're free to build your own UI, automation, or integrations on the API. Combined with GS SQL, the ODBC/JDBC adapter, OData, and MCP, the platform meets you wherever your stack lives.



    Does GroveStreams support custom branding?

    Yes. Bring your own logo and a branded subdomain (e.g. yourcompany.grovestreams.com). A “Powered by GroveStreams” attribution remains visible in the application. See the GroveStreams Website Guide for details.

    For licensing an entire private cluster, contact info@grovestreams.com.