Skip to main content

​
Overview

Getting data into Nebuly is simple by design. The platform exposes a single, vendor-agnostic Interaction API that you call to send your conversation logs. It captures interactions independent of model or vendor, and you decide what to send and when: in real time, in micro-batches, or in larger scheduled jobs that suit your business. You can find the technical documentation for the Interaction API.

​
What to send

Each interaction must include a few mandatory fields:
  • The user input (the user’s message).
  • The AI output (the model’s response).
  • A conversation ID that links interactions belonging to the same session.
Beyond those, it is highly recommended to enrich each payload with optional fields, especially tags. The segmentation, ROI, and risk views in Nebuly are only as good as the metadata you send.

​
When and how to send

Nebuly accepts data continuously. You can send interactions in real time as they happen or in larger scheduled batches (hourly, daily). Enrichment and clustering run on a recurring schedule, so insights for newly ingested data appear after the next processing cycle completes. A few practical guidelines:
  • Batched ingestion is recommended. You can pull from an existing conversation-history store (like an S3 Bucket) rather than instrument your app directly, to avoid unnecessary dependencies.
  • Automate the push. Use an internal script that reads from your conversation-history storage and pushes to the Interaction API on a regular schedule.

​
Tagging strategy

The Interaction API accepts a flexible tags payload of key-value pairs per interaction. For example: 
{
  "tags": {
    "department": "Finance",
    "role": "analyst",
    "customer_tier": "enterprise",
    "model_version": "v2.1"
  }
}
Defining your tagging taxonomy before you start sending data is the highest-leverage thing you can do at integration time. Tags drive every segmentation, ROI, and risk view in the platform. See Enrichment and the importance of tagging for the recommended taxonomy.

​
Security and privacy

Nebuly is built with a privacy-first architecture, so ingestion stays compliant with enterprise standards. Two independent controls are available on every interaction, and they can be combined:
  • Hide Content (hide_content = true). Hides the raw input/output text in the Nebuly UI. Nebuly still computes all analytics (topics, sentiment, frustration, error type) normally, but the text appears as ***. Use this when the conversation content is confidential but the behavioral analytics are not.
  • PII Anonymization (anonymize = true). Nebuly’s LLM-based intelligence detects and replaces personal information (names, emails, phone numbers, ID numbers) with pseudonyms before the data is processed. Use this when you need the platform to compute on cleaned, non-identifying text.

​
Beyond the per-interaction flags

For more advanced needs, additional PII handling can be configured at the project or tenant level, including regex-based PII removal and custom LLM-based detection rules. These are set up with the Nebuly team during onboarding. Reach out to your Nebuly contact or info@nebuly.ai to scope the right configuration.

​
What happens after ingestion

Once data is sent, Nebuly’s processing pipeline takes over in three stages:
  1. PII removal. Your anonymization rules (the anonymize flag and any project- or tenant-level rules) are applied first, before any enrichment runs.
  2. Enrichment (first batch job). Nebuly enriches each interaction with fields like user intent, topic, emotion, implicit feedback, keywords, and sentiment.
  3. Clustering (second batch job). Nebuly groups interactions to surface high-level patterns, running on a subset of the enriched signals: topics, implicit user feedback, and user intent.
For most projects, the first meaningful insights appear shortly after the first batch completes, and the analytics become more representative as volume grows.
To explore the results, see Navigating Nebuly. For the full request schema, available fields, and code samples, see the Interaction API documentation.