Build your dataset with Nebbos MCP
Enterprise Nebbos deployments run alongside your existing database, not on top of it. Your operational data — customer records, transactions, PII, business content — stays in your systems. Nebbos MCP reaches your data only through tools your tenant connects.
This page tells you exactly what Nebbos sees, what it stores, what leaves your systems, and how the dataset your team builds through the MCP surface stays under your control.
Data-handling matrix — what lives where
| Data class | Where it lives | Who can read it | Nebbos operator sees |
|---|---|---|---|
| Your operational data (customer records, transactions, PII, documents) | Your own database / object store / file system | Your team, per your ACL | Only what a tool your tenant connects passes through Nebbos, which processes it as your data processor |
| Attribution triples (user, tenant, session) | Nebbos-managed Postgres | Your tenant admins | Yes — required for audit chain integrity |
| Audit events (which tool was called, when, by whom, input hash, output hash) | Nebbos-managed Postgres | Your tenant admins | Yes — hashes only, not clear-text content |
| Memory shards (agent-authored observations about your operations) | Nebbos-managed Postgres, tenant-scoped RLS | Your tenant admins, your users | Today: Nebbos operator accounts can access it. Grants your tenant admin approves, time-limits and can revoke are planned. |
| Task rows (agent + human work items) | Nebbos-managed Postgres, tenant-scoped RLS | Your tenant admins, your users | Today: Nebbos operator accounts can access it. Grants your tenant admin approves, time-limits and can revoke are planned. |
| AI usage events (which model was called, tokens consumed, cost, latency) | Nebbos-managed Postgres | Your tenant admins, billing | Yes — telemetry only, not prompt content |
| Prompt content sent to LLM providers | Ephemeral in transit; not persisted by Nebbos | The provider you route to (Anthropic, Google, your self-hosted model) | Not persisted by Nebbos; provider retention per your provider contract |
| On-device notes and PDFs (individual user variant) | Local SQLite at ~/.nebbos/local/state.db or /Volumes/NebbosUSB/ | You, on that device only | Never — does not leave the device unless you invoke a sync tool |
The rule your legal team should read into a data-processing agreement: On the hosted platform, Nebbos is your data processor (a service provider under the CCPA) and signs a data processing agreement covering the data it stores and the data your connected tools pass through it.
What a Nebbos operator sees during an incident
If your team files an incident that requires Nebbos operator engagement, the operator has:
- Access by default: hashed audit events, model-call telemetry, error stack traces from Nebbos service code, aggregate rate-limit / SLA metrics.
- Access under explicit customer grant: your tenant memory contents, your task rows, your friction event bodies. Grant is issued via
POST /api/v1/capability-linksby your tenant admin, is scoped to a specific resource, is time-bounded (default 24h), and is revocable at any moment. - Nebbos holds no standing connection to your operational database; it reaches your systems only through tools your tenant connects.
Every capability-link grant emits an audit event on issuance, on each use, and on revocation. Your tenant admin can enumerate every grant ever issued.
Integration surface — how your data reaches the MCP
The MCP tools that read from your systems are connectors YOU configure. The connector is a callable your team writes (or picks from an approved catalog) that:
- Runs in your environment (your VPC, your machine, your container).
- Authenticates to your database with your credentials.
- Returns query results into the MCP tool’s response for a specific tool call.
The MCP tool call itself writes an audit record with the tool name, the redacted parameters and the outcome — Nebbos records that a query happened and who ran it, not what the query returned.
Data flow — one operation, end to end
What Nebbos stores about the operation
For the invoice-summary example above, Nebbos-managed Postgres stores exactly this:
{
"audit_event": {
"id": "0d6c5e1a-...",
"event_type": "agent.tool_call",
"actor_type": "agent",
"actor_id": "...",
"delegated_by": "...",
"occurred_at": "2026-11-09T12:34:56Z",
"hash": "9f2c...",
"previous_hash": "41ab..."
},
"ai_usage_event": {
"model": "your-selected-model",
"provider": "your-selected-provider",
"prompt_tokens": 1204,
"completion_tokens": 812,
"cost_units": 0.0042
}
}No invoice numbers. No customer names. No amounts. Just the fact that a tool ran, who ran it, and how much it cost.
What Nebbos builds up over time — your operational memory
Agents produce observations as they work. Those observations DO land in Nebbos-managed Postgres under your tenant scope (Layer 2 memory) — for example, a Pearl agent watching your finance department may write a memory shard "AR-aging bucket 60-90d has grown 12% MoM for the past 3 months". That shard is:
- Yours — stored under your
tenant_id, RLS-enforced. - Derived — an aggregate observation, not a copy of the underlying records.
- Auditable — every shard carries the author triple and links to the audit event that produced it.
- Deletable — your tenant admin can purge shards at any time; the audit record of the query remains for chain integrity but the referenced shard is gone.
- Operator access — today limited to Nebbos operator accounts; grants your tenant admin approves, time-limits and can revoke are planned.
The shard is Nebbos’s “learning” from your operation. It never contains raw records. It can always be regenerated from your operational data on demand — if you delete every Nebbos-side observation and re-run the agents against your DB, the observations are recomputed.
Sovereignty — the guarantees in one paragraph
On the hosted platform, Nebbos is your data processor and signs a data processing agreement. Nebbos stores your tenant data to run the service. Today, access to a client tenant is limited to Nebbos operator accounts; access grants that your tenant admin approves, time-limits and can revoke are planned. You can export every Nebbos-side row about your tenant at any time (§16 of the Technical Reference) and you can delete every Nebbos-side row at any time. If you terminate the relationship, your operational database goes with you unchanged; Nebbos returns your Nebbos-managed rows in a signed archive and purges them from Nebbos storage.
Individual-user variant — local plane
For individual users at L1 or L2 tier, without a customer-side database, Nebbos ships a local plane that builds a personal indexed dataset entirely on your device:
| Tool | Purpose |
|---|---|
mcp__nebbos-local__local_memory_note_write | Write a note into on-device SQLite |
mcp__nebbos-local__local_pdf_ingest | Parse a PDF via Docling, summarize with a local model, land as a note |
mcp__nebbos-local__local_memory_note_search | Search your notes |
mcp__nebbos-local__local_claude_memory_search | Search Claude memory shards on device |
mcp__nebbos-local__local_task_create | Track a discrete work item |
mcp__nebbos-local__nebos_friction_capture | Capture something the platform did not have; the classifier routes to existing tool or proposes a new one |
Store: ~/.nebbos/local/state.db (development), /Volumes/NebbosUSB/ (production, when the USB substrate is mounted). Nothing leaves the device unless you explicitly invoke orchestrator_sync_status and confirm sync.
In the individual-user local plane, data is kept in an on-device store; today it is not synced to Nebbos servers.
What “clean” means for your dataset
Nebbos’s data-hygiene stance across every plane:
- Every write lands raw. No silent dedup, no silent normalization, no silent rejection at ingest. What you write is what stays.
- Cleanliness is a query concern, not a write concern. Search filters, projections, and aggregate views handle “clean” at read time; the underlying rows remain as primary records.
- Attribution is the truth anchor. Every row carries
(user, tenant, session, authored_at). When rows disagree, both remain queryable; derived views apply the ranking rules you configure. - Reference chains are load-bearing. A task grounded in three memory shards remains grounded forever; removing a referenced row is an explicit multi-step action that surfaces the chain, never a background cleanup.
Failure modes
| Failure | Effect | Recovery |
|---|---|---|
| Your connector unreachable | Tool call returns error; NO fallback data source | Fix your connector; retry the tool call |
| Nebbos audit chain gap | Do not trust downstream reports | POST /api/v1/tenants/{tenant_id}/audit/investigate |
| Capability-link grant expired mid-incident | The access that grant gave ends | Reissue grant with new TTL; every access re-logged |
| Local plane store missing (fresh machine) | First write auto-provisions the SQLite file | No action required |
Reading paths
- The Cradle substrate — how the layered stack composes with your BYODB
- Security model — encryption, key management, RLS enforcement
- Row-level isolation — the RLS three-statement pattern on Nebbos-managed rows
- Audit chain — hash-chain verification for Nebbos-side metadata
- Trust Center — data-processing agreement templates, subprocessor list, compliance evidence