Product Integration

Turn every user action into organizational knowledge.

The average knowledge worker uses 11 different SaaS tools every day. The decisions, context, and rationale behind their work disappears the moment they close the tab.

The problem

Your users make hundreds of decisions a day inside your product — approving invoices, closing tickets, writing comments, updating records. Each action carries context and rationale that never gets captured. Six months later, someone asks "why did we do it this way?" and the answer is gone. The knowledge was there, in the moment, but your product let it slip away.

How it works

Here's how you build your knowledge graph step by step using the ai CLI.

Integrate the Apart SDK

Add Apart Intelligence to your product with a few lines of code. The SDK captures knowledge from user actions without changing their workflow.

import { Apart } from '@apart-tech/apart-sdk';

const apart = new Apart({
  apiKey: process.env.APART_API_KEY,
  tenantId: customer.orgId,
});

Each customer gets their own isolated knowledge graph. Multi-tenant by default.

Capture actions as knowledge nodes

When users take actions in your product — closing a deal, resolving a ticket, approving a document — capture the context behind the action.

// When a sales rep closes a deal
await apart.add({
  title: "Won: Acme Corp Enterprise Deal",
  body: "Closed $240k ARR. Key factors: champion was VP Eng, " +
    "competitive displacement from Datadog, 3-month eval. " +
    "Discount: 15% for annual commit. Legal flagged " +
    "custom DPA — used template from Globex deal.",
  type: "decision",
  domain: "sales",
  metadata: { dealId: deal.id, owner: rep.email }
});

The knowledge node captures why the deal closed, not just that it did.

Capture notes and comments in context

Every comment, note, and annotation your users write is knowledge. Capture it with the context of what they were looking at when they wrote it.

// When a user adds a comment on a ticket
await apart.add({
  title: "Note on " + ticket.title,
  body: comment.text,
  type: "note",
  domain: ticket.category,
  relations: [
    { target: ticket.knowledgeId, type: "annotates" },
    { target: customer.knowledgeId, type: "relates-to" }
  ]
});

Comments are linked to the ticket and customer they reference — context is preserved automatically.

Link actions to build a knowledge graph

As users work, their actions create a connected graph of decisions, processes, and context that grows richer over time.

// When a support agent escalates a ticket
await apart.add({
  title: "Escalation: Payment API timeout for Acme Corp",
  body: "Customer hitting 30s timeouts on batch payments. " +
    "Tried standard retry config — didn't help. " +
    "Root cause likely connection pool exhaustion " +
    "(similar to Globex issue in Q3).",
  type: "note",
  domain: "support",
  relations: [
    { target: acmeNodeId, type: "relates-to" },
    { target: paymentApiNodeId, type: "affects" },
    { target: globexIncidentId, type: "similar-to" }
  ]
});

The escalation is linked to the customer, the affected system, and a similar past incident — pattern recognition becomes automatic.

Surface knowledge where users work

When a user opens a record, show them relevant knowledge from across the organization. The right context appears at the right moment.

// When an account manager opens a customer profile
const context = await apart.context(
  "What do I need to know about " + customer.name + "?",
  { domain: ["sales", "support", "engineering"] }
);

// Returns: deal history, open issues, past escalations,
// technical decisions, related customers — all connected

Users get organizational memory surfaced inside your product, not in a separate tool they have to go find.

AI features powered by real context

Build AI features in your product that are grounded in actual organizational knowledge, not just the current screen.

// AI assistant in your product
const response = await apart.context(
  "Draft a renewal proposal for " + customer.name
);

// AI gets: full deal history, support interactions,
// product usage patterns, competitive landscape,
// what worked in similar renewals — automatically

Your AI features go from generic to genuinely useful because they have the full picture.

Knowledge compounds across every user

Every user action makes the knowledge graph richer. Sales learns from support. Engineering context flows to customer success. The entire organization gets smarter as people work.

// The knowledge graph grows passively
// Day 1:    50 nodes — initial setup
// Month 1:  2,400 nodes — team is using the product
// Month 6:  18,000 nodes — patterns emerge automatically
// Year 1:   50,000+ nodes — institutional memory is deep

// Query across all domains
const insights = await apart.context(
  "Which customers have had payment API issues?",
  { domain: ["support", "engineering", "sales"] }
);

Knowledge builds up as a side effect of people doing their jobs. No extra effort required.

Your product becomes the knowledge layer

Every action your users take builds organizational knowledge. AI features are grounded in real context. Your product becomes more valuable the longer teams use it — not because of lock-in, but because it actually knows their business.

Knowledge builds passively while users do their actual work

AI features are grounded in real organizational context, not just prompts

Cross-functional knowledge flows automatically between teams

Your product becomes the system of record for institutional memory

Start building your knowledge graph

Free during beta. No credit card required.