Datasynx Agentic CRM

local-first MCP-native open source enterprise-ready

The CRM your AI agents actually run. Every customer lives on your machine as plain Markdown — no cloud, no SaaS pricing, no vendor lock-in. Your AI agents read, reason about, and update it directly via the Model Context Protocol. 78 MCP tools, hybrid search, deal & revenue intelligence, RBAC, GDPR erasure, an encrypted vault, SSO — and zero telemetry. All built in.

# 1. Install globally
npm install -g @datasynx/agentic-crm

# 2. Initialize (auto-detects Claude Code, Codex, Cursor, Grok, ...)
dxcrm init

# 3. Create your first customer
dxcrm create "Acme Corp" --domain acme.com --email ceo@acme.com

# Your AI agent can now answer:
# "What's going on with Acme Corp?" → answer in <3 seconds

Installation

Requirements

• Node.js 18+ (for native fetch and crypto)
• An AI framework: Claude Code, Codex CLI, Cursor, or any MCP-compatible client

Install

# Global install (recommended)
npm install -g @datasynx/agentic-crm

# Or local to a project
npm install datasynx-opencrm
npx dxcrm init

Initialize

# Solo developer
dxcrm init

# Team (connects to shared HTTP server)
dxcrm init --team http://vm-ip:3847/mcp

dxcrm init auto-detects all installed AI frameworks and registers the MCP server. No manual config needed for Claude Code, Codex, Grok, Cursor, Windsurf, Cline, Claude Desktop, Hermes, or OpenClaw.

Data Structure

your-project/
├── customers/
│   └── acme-corp/
│       ├── main_facts.md      # Customer profile (YAML frontmatter)
│       ├── interactions.md    # All calls/emails/meetings (newest first)
│       ├── pipeline.md        # Deal stages
│       ├── sources.json       # Gmail query, transcript paths
│       ├── attachments/       # PDFs, contracts, proposals
│       └── transcripts/       # Meeting recordings
│
└── .agentic/
    ├── config.json            # CRM configuration
    ├── sources.json           # Global sync sources
    ├── audit.log              # Append-only audit trail
    ├── rbac.json              # Role assignments
    ├── gdpr-erasures.json     # Erasure protocol
    ├── pipeline-stages.json   # Custom stage config
    ├── server.pid             # HTTP server PID (team mode)
    ├── lancedb/               # Vector search index (auto-managed)
    └── agents/                # Per-customer agent configs
        └── acme-corp.agent.json

dxcrm init

Initialize Datasynx Agentic CRM. Detects AI frameworks and registers the MCP server in all of them.

dxcrm init
dxcrm init --team http://vm-ip:3847/mcp   # Team mode

dxcrm create

dxcrm create "Acme Corp" --domain acme.com --email ceo@acme.com

Creates customers/acme-corp/ with all required files. Slug is auto-generated from the name (lowercase, hyphens).

dxcrm sync

Sync emails, transcripts, and cloud files into LanceDB for semantic search.

dxcrm sync                                 # Gmail (default)
dxcrm sync --provider gmail                # Explicit Gmail
dxcrm sync --provider microsoft            # Outlook via Graph API
dxcrm sync --provider google-drive        # Google Drive/Docs
dxcrm sync --provider teams-transcripts   # Microsoft Teams
dxcrm sync --provider google-meet         # Google Meet
dxcrm sync --provider transcripts         # Local transcript files

dxcrm session

dxcrm session open acme-corp           # Set active customer
dxcrm session open acme-corp --owner alice
dxcrm session close
dxcrm session status

The active session is returned by get_active_session(). Set DXCRM_ACTOR to attribute writes to a team member.

dxcrm import

Import customers and interactions from any CRM. Two-pass: creates customers first, then imports activities. Idempotent — re-running skips already-imported rows.

# CSV / HubSpot export file
dxcrm import contacts.csv
dxcrm import hubspot-export.csv --from hubspot --dry-run

# HubSpot API (v4 Associations — full history)
dxcrm import --from hubspot --mode api --token $HUBSPOT_TOKEN

# Salesforce REST API (contacts + tasks)
dxcrm import --from salesforce --mode api \
  --token $SFDC_TOKEN --url https://myco.salesforce.com

# Pipedrive REST API (persons + activities)
dxcrm import --from pipedrive --mode api \
  --token $PIPEDRIVE_TOKEN --url https://myco.pipedrive.com

dxcrm stages

Manage custom pipeline stages. Stored in .agentic/pipeline-stages.json.

dxcrm stages list                                                  # List all stages
dxcrm stages set discovery "Discovery" --order 3 --probability 40  # Create/update
dxcrm stages set signed "Signed" --final --color "#3fb950"          # Terminal stage
dxcrm stages delete discovery                                       # Remove stage
dxcrm stages reset                                                   # Back to defaults

Default stages

dxcrm plugin

Manage the plugin registry.

dxcrm plugin list              # List all registered plugins
dxcrm plugin info slack        # Show plugin details + MCP tools it exposes

dxcrm status

dxcrm status                # Daemon state, sync ages, customer count
dxcrm status --unmatched    # List unmatched transcript queue

dxcrm agent

Spawn a wake-triggered agent that sends Telegram notifications on new email activity.

dxcrm agent spawn acme-corp --channel telegram
dxcrm agent spawn acme-corp --channel telegram --chat-id 12345
dxcrm agent status
dxcrm agent remove acme-corp

Requires: TELEGRAM_BOT_TOKEN + TELEGRAM_CHAT_ID environment variables.

dxcrm server

Start a shared HTTP MCP server for team use.

dxcrm server start                                # Port 3847
dxcrm server start --port 3847 --data /mnt/crm-data
dxcrm server status

Each team member adds url: http://vm-ip:3847/mcp to their framework config, then sets export DXCRM_ACTOR=alice.

dxcrm audit

Append-only audit trail. Every write operation is logged with actor, tool, customer, and summary.

dxcrm audit                          # Last 20 entries
dxcrm audit --slug acme-corp         # Filter by customer
dxcrm audit --actor alice            # Filter by actor
dxcrm audit --limit 100

# Log format:
# 2026-06-01T09:14:00Z | alice | log_interaction | acme-corp | Renewal call

dxcrm forecast

Weighted pipeline forecast — total, by stage, and per owner. RBAC-aware: a rep sees only their own customers' deals; manager/admin see the full team rollup.

dxcrm forecast                  # total + by-stage
dxcrm forecast --by-owner        # per-owner rollup
dxcrm forecast --owner alice      # drill into one rep

dxcrm rbac

Role-based access control. Roles are stored in .agentic/rbac.json. Config is optional — without it all calls are allowed (solo mode).

dxcrm rbac set alice admin
dxcrm rbac set bob rep
dxcrm rbac show
dxcrm rbac check alice update_deal    # Exit 0 = allowed

Actor identity: export DXCRM_ACTOR=alice. Default role when no rbac.json exists: unrestricted (solo mode).

dxcrm gdpr

GDPR erasure with dry-run safety. Always run without --confirm first.

dxcrm gdpr erase acme-corp              # Dry-run: shows plan
dxcrm gdpr erase acme-corp --confirm    # Permanent deletion
dxcrm gdpr list-erasures               # Erasure history

On confirmed erasure: deletes customers/<slug>/, drops LanceDB vector table, writes audit entry, appends to gdpr-erasures.json.

dxcrm backup / restore

dxcrm backup                                  # ./backup-YYYY-MM-DD.zip
dxcrm backup ./my-backup.zip
dxcrm backup schedule --every day --keep 7   # Auto-backup via daemon
dxcrm backup schedule --status
dxcrm restore ./backup.zip

MCP Tool: get_capabilities

Returns the complete tool guide. Call this first in a new session.

get_capabilities()
// Returns: this documentation as a Markdown string

MCP Tool: get_customer_context

Full customer brief in under 3 seconds.

get_customer_context({ slug: "acme-corp" })

// Returns: structured Markdown with:
// - Quick Reference (name, domain, stage, deal value)
// - Contacts
// - Critical Context
// - Recent Activity (last 10 interactions)
// - Pipeline (all deals)
// - Open Questions / Next Steps

MCP Tool: search_customer_knowledge

Semantic + full-text hybrid search across all emails and transcripts for a customer.

search_customer_knowledge({
  slug: "acme-corp",
  query: "pricing discussion Q3",
  limit: 5   // optional, default 5
})

// Returns: { results: [{ content, score, source }] }

MCP Tool: list_customers

list_customers({ filter: "acme" })   // filter is optional

// Returns: [{ slug, name, stage, lastInteraction, dealValue }]

MCP Tool: log_interaction

Record a call, email, or meeting. Use after every customer touchpoint.

log_interaction({
  slug: "acme-corp",
  type: "Call",              // Call | Email | Meeting | Note | Demo | Proposal | Contract | Other
  summary: "Discussed renewal. Budget confirmed at €50k.",
  with: "Alice Smith",
  nextSteps: ["Send proposal by Friday"],
  direction: "inbound"      // inbound | outbound — optional
})

// Returns: { success, path, entry }
// RBAC: rep+ · writes audit entry

MCP Tool: update_deal

Update or create a pipeline deal. Upserts by deal name.

update_deal({
  slug: "acme-corp",
  dealName: "Enterprise License 2026",
  stage: "negotiation",
  value: 75000,
  probability: 75,
  closeDate: "2026-09-30",
  notes: "Legal review pending"
})

// Returns: { success, deal }
// RBAC: rep+ · writes audit entry

MCP Tool: update_customer_facts

Update fields in a customer's profile. Merges patch; preserves unmentioned fields.

update_customer_facts({
  slug: "acme-corp",
  domain: "new-acme.io",
  primaryContact: "Bob Jones",
  relationshipStage: "active",  // prospect | active | churned | paused
  tags: ["enterprise", "strategic"],
  industry: "SaaS"
})

// Returns: { success, facts }
// RBAC: admin only · writes audit entry

MCP Tool: export_customer

export_customer({ slug: "acme-corp", format: "json" })  // json | markdown

// JSON: { slug, exportedAt, mainFacts, interactionsCount, pipeline }
// Markdown: formatted briefing document

MCP Tool: get_active_session

get_active_session()

// Returns: { hasSession, customerSlug?, customerName?, startedAt?, owner? }

MCP Tool: get_deal_health

Score all deals for a customer. Useful for prioritization and pipeline reviews.

get_deal_health({ slug: "acme-corp" })

// Returns:
{
  deals: [
    {
      name: "Enterprise License 2026",
      stage: "negotiation",
      value: 75000,
      score: 82,       // 0–100
      grade: "B",      // A ≥90, B ≥75, C ≥60, D ≥40, F <40
      warnings: ["No interaction in 14 days"]
    }
  ]
}

MCP Tool: get_pipeline_forecast

Aggregate weighted pipeline revenue across all customers by stage.

get_pipeline_forecast()

// Returns:
{
  total: 347500,
  weighted: 189250,
  byStage: {
    lead:        { count: 3, raw: 45000,  weighted: 4500  },
    qualified:   { count: 2, raw: 80000,  weighted: 24000 },
    negotiation: { count: 2, raw: 75000,  weighted: 56250 },
    won:         { count: 1, raw: 27500,  weighted: 27500 }
  }
}

MCP Tool: summarize_meeting

Summarize a transcript via LLM and log the interaction automatically.

summarize_meeting({
  slug: "acme-corp",
  transcript: "Alice: Thanks for joining. We discussed the Q3 renewal...",
  with: "Alice Smith",
  date: "2026-05-27"   // optional
})

// Returns: { success, summary, nextSteps[], interactionLogged }
// Requires: ANTHROPIC_API_KEY or OPENAI_API_KEY
// RBAC: rep+

MCP Tool: get_pipeline_stages

Returns all configured pipeline stages. Reflects custom stages set via dxcrm stages set.

get_pipeline_stages()

// Returns:
{
  stages: [
    { id: "lead", label: "Lead", order: 1, probability: 10, color: "#8b949e" },
    { id: "qualified", label: "Qualified", order: 2, probability: 30 },
    // ...
  ]
}

MCP Tool: get_market_intelligence

Search interaction history across all customers for patterns, competitor mentions, or objection themes.

get_market_intelligence({
  query: "competitor pricing objection",
  limit: 10    // optional
})

// Returns:
{
  results: [
    { customer: "acme-corp", content: "Mentioned Salesforce...", score: 0.91, source: "gmail://..." },
    { customer: "beta-gmbh", content: "Asked for HubSpot comparison...", score: 0.87 }
  ]
}

MCP Tool: get_relationship_health

Returns health scores for all contacts. Scores decay automatically when communication cadence breaks — no manual input required. Auto-updates after every log_interaction.

get_relationship_health({ slug: "acme-corp" })

// Returns:
{
  overallHealth: 58,
  atRiskContacts: ["cfo@acme.com"],
  coldContacts:   ["cfo@acme.com"],
  contacts: [
    { name: "Max Miller",    score: 72, grade: "B", trend: "stable",   riskFlags: [],                         recommendation: "..." },
    { name: "Thomas Berger", score: 18, grade: "F", trend: "cold",    riskFlags: ["NO_CONTACT_30D", "CHAMPION_SILENT"], recommendation: "Re-engage urgently..." }
  ]
}

Score formula: Recency 35% · Cadence 25% · Sentiment 20% · Response 10% · Momentum 10%. Grades: A ≥ 80 · B ≥ 60 · C ≥ 40 · D ≥ 20 · F < 20.

MCP Tool: get_relationship_graph

Returns the knowledge graph for a customer — contacts, companies, and their relationships. Auto-populated from every log_interaction call. No setup required.

get_relationship_graph({ slug: "acme-corp" })

// Returns:
{
  nodeCount: 4, edgeCount: 3,
  stakeholders: {
    champions:      [{ id: "person:alice@acme.com", name: "Alice", email: "alice@acme.com" }],
    blockers:       [],
    economicBuyers: [{ id: "person:cfo@acme.com",   name: "Thomas", email: "cfo@acme.com" }],
    allContacts:    [ ... ],
    missingRoles:   []          // or [{ role: "champion", urgency: "important", suggestion: "..." }]
  },
  nodes: [ ... ],  // full GraphNode[]
  edges: [ ... ]   // full GraphEdge[] with weight (0–1), sentiment, contactCount
}

Edge weight grows +0.05 per interaction (max 1.0). Edge types: WORKS_AT, IS_CHAMPION, IS_BLOCKER, IS_ECONOMIC_BUYER, KNOWS, INTRODUCED_BY, OWNS_DEAL, COMPETES_WITH.

Graph is stored in customers/<slug>/graph.json and erased by dxcrm gdpr erase.

MCP Tool: run_deal_agent

Analyze a specific deal and generate a prioritized action plan. Supports three autonomy levels — from read-only analysis to autonomous action execution.

run_deal_agent({
  slug: "acme-corp",
  dealName: "Q3 Renewal",
  autonomyLevel: "suggest",    // "observe" | "suggest" | "act"
  instruction: "Focus on close date risk",  // optional
  valueThreshold: 50000         // EUR — no auto-exec above this (default: 50000)
})

// Returns:
{
  assessment: "Deal in negotiation, close date approaching in 19 days...",
  riskLevel: "medium",
  plan: [{ step: 1, action: "Send final proposal", priority: "high", reason: "..." }],
  actionsQueued:   [ ... ],  // suggest/act mode: pending approval
  actionsExecuted: [ ... ],  // act mode: auto-executed
  trace: { timestamp, observation, plan, actionsConsidered, outcome }
}

Autonomy levels:

• observe — read-only analysis, no side effects, no queue writes
• suggest (default) — queues all actions in agent-queue.json for human review
• act — auto-executes actions with confidence ≥ 0.7 and value < valueThreshold

Signals analyzed: deal health (A–F grade), relationship health per contact, stakeholder gaps (missing champion / economic buyer), recent interaction summary.

LLM fallback: rule-based analysis when ANTHROPIC_API_KEY is unset or LLM fails — always returns a valid result.

Glass-box trace: every decision is in result.trace — inspectable for EU AI Act Art. 13 compliance.

MCP Tool: approve_agent_action

Approve or reject a pending action from the deal agent queue. Find actionId in run_deal_agent response.

// Approve: executes the action immediately
approve_agent_action({
  slug: "acme-corp",
  actionId: "da_1748346900000_a3f7x2",
  approved: true
})
// → { success: true, actionId: "da_...", status: "executed" }

// Reject: marks action as rejected, no execution
approve_agent_action({
  slug: "acme-corp",
  actionId: "da_1748346900000_a3f7x2",
  approved: false
})
// → { success: true, actionId: "da_...", status: "rejected" }

Queue is persisted at customers/<slug>/agent-queue.json. Erased by dxcrm gdpr erase.

Supported action types: log_interaction, update_deal, alert, schedule_meeting.

MCP Tool: simulate_revenue

Monte Carlo pipeline revenue simulation with P10/P50/P90 confidence intervals. Adjusts deal win probabilities using relationship health (D12) and champion presence (D11).

simulate_revenue({ horizon: "quarter", iterations: 10000 })

// Returns:
{
  forecast: {
    p10: 145000, p50: 287500, p90: 412000,
    expected: 289300, stdDev: 82000,
    atRiskRevenue: 75000,
    byCloseMonth: { "2026-06": { p50: 120000, range: [80000, 165000] } },
    topRisks: [ "acme-corp/Enterprise License: health 38 — €75k at risk" ],
    sensitivityMap: { "Enterprise License": 56250 }
  },
  confidence: "P50 forecast: €287.5k with ±€133.5k uncertainty. 28% at risk.",
  dealCount: 5,
  horizon: "quarter"
}

Probability adjustment: Base stage probability + health adjustment (health 60 = neutral) + champion bonus (+5%). External signals ready for D18.

sensitivityMap: Expected revenue contribution per deal. Sort descending to find which deal matters most for the forecast.

topRisks: Top 5 at-risk deals (health < 60 or 14+ days no contact), sorted by forecast impact.

MCP Tool: get_playbook

Retrieve playbooks matching the current deal situation. Without deal context, returns all playbooks for the customer. Sorted by success rate (highest first). run_deal_agent uses this automatically.

get_playbook({ slug: "acme-corp", stage: "negotiation", value: 75000, daysSinceContact: 10 })

// Returns:
{
  matches: [{ name: "enterprise-renewal", score: 1.0, trigger: "deal_stage_negotiation AND value > 50000", successRate: 0.73, usedCount: 8, content: "..." }],
  totalPlaybooks: 3,
  slug: "acme-corp"
}

Trigger DSL: AND-only conditions. Tokens: deal_stage_<s>, value > N, value < N, days_stalled > N, days_stalled < N, health < N, health > N, no_champion, has_champion. Only score=1.0 matches returned.

MCP Tool: create_playbook

Create or update a playbook encoding proven tactics for a specific deal situation. Upserts by name. Stored at customers/<slug>/playbooks/<kebab-name>.md.

create_playbook({
  slug: "acme-corp",
  name: "enterprise-renewal",
  trigger: "deal_stage_negotiation AND value > 50000 AND days_stalled > 7",
  content: "# Enterprise Renewal\n\n## Steps\n1. Call economic buyer.",
  successRate: 0.73
})
// Returns: { success: true, playbook: { name, trigger, successRate, path } }

MCP Tool: list_playbooks

List all playbooks for a customer (metadata only — no body content for performance).

list_playbooks({ slug: "acme-corp" })
// Returns: { playbooks: [{ name, trigger, successRate, usedCount, lastUpdated }], count, slug }

MCP Tool: distill_playbook

Use LLM to extract a reusable playbook from a won or lost deal's interaction history. Run after every won or lost deal to build procedural memory. Analyzes interactions.md and writes a structured playbook file.

distill_playbook({ slug: "acme-corp", dealName: "Q3 Enterprise License", outcome: "won" })

// Returns:
{
  success: true,
  playbook: { name: "enterprise-q3-renewal", trigger: "deal_stage_negotiation AND value > 50000", successRate: 1.0, path: "..." },
  reasoning: "Deal won by ROI framing. Champion was CEO."
}

Fallback successRate: won → 1.0, lost → 0.0 when LLM omits the field. Error cases: missing interactions.md or unparseable LLM response.

MCP Tool: pursue_goal

Set a revenue or pipeline goal and get a decomposed action plan. Analyzes current pipeline P50 (Monte Carlo, D14), calculates the gap, and ranks deals by weighted leverage (value × probability × health). Persists goal to .agentic/goals.json. RBAC: manager+

pursue_goal({ goal: "Close €500k ARR this quarter", deadline: "2026-09-30" })

// Returns:
{
  goalId: "goal_1748697600000_a3f7x2",
  target: 500000,
  decomposition: {
    analysis: "Current pipeline P50: €287k. Gap: €213k. 3 deal(s) identified.",
    currentPipeline: 287000, gap: 213000,
    subGoals: [{ priority: 1, action: "Accelerate acme-corp/Enterprise License", targetDelta: 75000, nextStep: "..." }],
    probabilisticOutcome: "If all recommended deals close: ~€512k"
  }
}

Target parsing: €500k → 500000, $2M → 2000000, €1.5 million → 1500000. Goal type auto-inferred: revenue / pipeline / relationship / churn_prevention.

MCP Tool: get_goal_status

Get all active goals or a specific goal by ID. Returns progress, days remaining, and top sub-goals.

get_goal_status()                              // all active goals
get_goal_status({ goalId: "goal_abc123" })   // specific goal

// Returns:
{ goals: [{ id, description, target, progress, status, deadline, daysRemaining, subGoals }], activeCount, completedCount }

CLI: dxcrm goal set "..." --deadline YYYY-MM-DD · dxcrm goal status · dxcrm goal update <id> --progress N · dxcrm goal cancel <id>

MCP Tool: register_push_subscription

Register a real-time push subscription so providers send events to dxcrm within seconds — instead of polling every 30 minutes. Supports Gmail Pub/Sub, Microsoft Graph webhooks, and Slack Events API.

// Gmail Pub/Sub
register_push_subscription({
  provider: "gmail",
  slug: "acme-corp",
  webhookUrl: "https://myserver.com/webhooks/gmail",
  gmailTopicName: "projects/my-project/topics/gmail-push"
})

// Microsoft Graph
register_push_subscription({
  provider: "microsoft-graph",
  slug: "acme-corp",
  webhookUrl: "https://myserver.com/webhooks/microsoft",
  microsoftClientState: "my-hmac-secret"
})

// Slack Events
register_push_subscription({
  provider: "slack",
  slug: "acme-corp",
  webhookUrl: "https://myserver.com/webhooks/slack",
  slackTeamId: "T12345"
})

// Returns:
{ subscriptionId, provider, slug, status, expiresAt, warning? }

RBAC: admin only · Webhook endpoints: POST /webhooks/gmail · ALL /webhooks/microsoft · POST /webhooks/slack

CLI: dxcrm push register <slug> --provider gmail --webhook-url <url>

MCP Tool: get_push_status

Show all active push subscriptions with expiry countdown, events processed, and renewal status.

get_push_status()                              // all subscriptions
get_push_status({ slug: "acme-corp" })       // filter by customer
get_push_status({ provider: "gmail" })       // filter by provider

// Returns:
{
  subscriptions: [{ id, provider, slug, status, expiresInHours, needsRenewal, eventsProcessed }],
  summary: { total, active, expiringSoon, expired }
}

needsRenewal: true when fewer than 24 hours until expiry. Gmail subscriptions auto-renew via daemon cron at 06:00 daily.

CLI: dxcrm push status · dxcrm push revoke <id> · dxcrm push renew --all

Gmail Integration

# Place OAuth credentials:
.agentic/gmail-credentials.json   # OAuth2 client credentials
.agentic/gmail-token.json         # Access token (auto-refreshed)

# Per-customer Gmail query (in customers/acme-corp/sources.json):
{ "gmail": { "query": "from:acme.com OR to:acme.com", "enabled": true } }

Gmail sync uses push notifications (registerGmailWatch) for real-time delivery, with fetchNewMessagesFromHistory on each webhook. MIME parsing handles quoted replies and base64url-encoded bodies. Dedup by message ID + normalized subject.

Microsoft Outlook Integration

# Write your Microsoft Graph access token:
echo '{"accessToken":"ey..."}' > .agentic/microsoft-token.json

dxcrm sync --provider microsoft

# sourceRef format: microsoft://message/<message-id>

Uses the Microsoft Graph calendarView API with @odata.nextLink pagination. Supports both accessToken (camelCase) and access_token (snake_case) in the token file.

Google Drive Integration

dxcrm sync --provider google-drive

# Auth via service account:
export GOOGLE_SERVICE_ACCOUNT_KEY='{"type":"service_account","project_id":"..."}'

Exports Google Docs as plain text via the Drive export API. Tracks modifiedTime for incremental sync. All file content is indexed into LanceDB under the matching customer slug.

Microsoft Teams & Google Meet

# Teams (requires OnlineMeetings.Read + CallRecords.Read.All)
dxcrm sync --provider teams-transcripts

# Google Meet (requires service account with Meet API)
dxcrm sync --provider google-meet

Both providers use page-token/nextLink pagination and write transcripts as Meeting interactions.

HubSpot Integration (v4 API)

dxcrm import --from hubspot --mode api --token $HUBSPOT_TOKEN

Uses the HubSpot v4 Associations API to fetch all engagements (notes, calls, emails, meetings) linked to each contact. Cursor-based pagination handles any account size. Rate-limit retry via RateLimiter (10 req/s). Dedup by sourceRef.

Required HubSpot private app scopes

• crm.objects.contacts.read
• crm.objects.engagements.read
• crm.associations.read

Salesforce Integration

dxcrm import --from salesforce --mode api \
  --token $SFDC_TOKEN --url https://myco.salesforce.com

Two-pass: Contact SOQL → customers, Task SOQL (linked via WhoId) → interactions. Also supports Bulk API v2 for large exports: POST job → poll until jobComplete → stream CSV with Sforce-Locator pagination.

Pipedrive Integration

dxcrm import --from pipedrive --mode api \
  --token $PIPEDRIVE_TOKEN --url https://myco.pipedrive.com

Uses cursor pagination via additional_data.next_cursor (Pipedrive v2). Persons → customers, Activities → interactions.

Other CRM Connectors

All connectors implement the CrmConnector interface and support the same --from <name> --mode api import syntax:

AI Framework Configuration

dxcrm init handles this automatically. Manual config if needed:

Claude Code (~/.claude.json)

{
  "mcpServers": {
    "datasynx-opencrm": {
      "type": "stdio",
      "command": "node",
      "args": ["/path/to/node_modules/@datasynx/agentic-crm/dist/mcp.js"]
    }
  }
}

Grok Build (~/.grok/user-settings.json)

Note: Grok uses an array for mcpServers, not an object map.

{
  "mcpServers": [
    {
      "name": "datasynx-opencrm",
      "transport": {
        "type": "stdio",
        "command": "node",
        "args": ["/path/to/node_modules/@datasynx/agentic-crm/dist/mcp.js"],
        "env": { "DXCRM_DATA_DIR": "/path/to/.dxcrm" }
      }
    }
  ]
}

Team / HTTP Mode

{
  "mcpServers": {
    "datasynx-opencrm": {
      "type": "http",
      "url": "http://vm-ip:3847/mcp"
    }
  }
}

Plugin: Slack

Get a Slack message after every interaction and deal update.

import { createSlackPlugin } from "datasynx-opencrm/dist/plugins/slack.js";
import { registerPlugin } from "datasynx-opencrm/dist/core/plugin-registry.js";

registerPlugin(createSlackPlugin({
  webhookUrl: process.env.SLACK_WEBHOOK_URL!,
  channel: "#crm-updates"    // optional
}));

The plugin hooks afterLogInteraction and afterDealUpdate. Messages include customer name, interaction type, summary, and next steps.

Plugin: Stripe

Adds get_stripe_context MCP tool — look up subscription revenue for any customer.

import { createStripePlugin } from "datasynx-opencrm/dist/plugins/stripe.js";

registerPlugin(createStripePlugin({
  apiKey: process.env.STRIPE_SECRET_KEY!
}));

// AI agent can then call:
get_stripe_context({ slug: "acme-corp" })
// Returns: { customer, subscriptions[], mrr, currency }

Plugin: Linear

Adds get_linear_issues MCP tool — fetch open engineering issues linked to a customer.

import { createLinearPlugin } from "datasynx-opencrm/dist/plugins/linear.js";

registerPlugin(createLinearPlugin({
  apiKey: process.env.LINEAR_API_KEY!
}));

// AI agent can then call:
get_linear_issues({ slug: "acme-corp" })
// Returns: { issues: [{ id, title, status, priority, url }] }

Uses the Linear GraphQL API. Issues are matched by customer name or domain tag.

Custom Plugins

Implement the DxcrmPlugin interface:

import { registerPlugin, DxcrmPlugin } from "datasynx-opencrm/dist/core/plugin-registry.js";

const myPlugin: DxcrmPlugin = {
  name: "my-plugin",
  version: "1.0.0",
  description: "My custom integration",
  mcpTools: [],           // additional MCP tools this plugin exposes
  onInstall: async () => { /* setup logic */ },
  onUninstall: async () => { /* teardown logic */ },
};

registerPlugin(myPlugin);

Team Setup

1. Start Server (VM)

dxcrm server start --data /mnt/crm-data --port 3847

2. Configure Roles

dxcrm rbac set alice admin
dxcrm rbac set bob manager
dxcrm rbac set carol rep

3. Each Team Member

dxcrm init --team http://vm-ip:3847/mcp
export DXCRM_ACTOR=alice   # Add to ~/.bashrc or ~/.zshrc

Role-Based Access Control

Config: .agentic/rbac.json. Actor: DXCRM_ACTOR env var. When no rbac.json exists, all calls are allowed (solo mode — backward compatible).

{ "actors": { "alice": "admin", "bob": "manager", "carol": "rep" }, "default": "rep" }

RBAC is enforced at MCP tool call time. Denied calls return an error with the actor name and required role.

GDPR Compliance

Datasynx Agentic CRM never sends data to external servers. All data stays on your machine — eliminating the cloud GDPR risk that affects every SaaS CRM.

# Always dry-run first:
dxcrm gdpr erase acme-corp

# Permanent deletion after review:
dxcrm gdpr erase acme-corp --confirm

# Audit trail of all erasures:
dxcrm gdpr list-erasures

Erasure deletes: customers/<slug>/ directory (recursive), LanceDB vector table for the customer, audit entry in audit.log, record in gdpr-erasures.json.

Field Encryption (AES-256-GCM)

Sensitive fields can be encrypted at rest using AES-256-GCM with scrypt key derivation.

import { encryptField, decryptField } from "datasynx-opencrm/dist/core/encryption.js";

const secret = process.env.DXCRM_ENCRYPTION_SECRET!;  // 32+ char secret

// Encrypt before writing to disk:
const encrypted = await encryptField(secret, "sensitive value");
// encrypted = Buffer (iv + authTag + ciphertext)

// Decrypt on read:
const plain = await decryptField(secret, encrypted);

Key derivation: scrypt(secret, salt, 32). Each field gets a unique 16-byte IV. Authentication tag prevents tampering. Set DXCRM_ENCRYPTION_SECRET env var to enable.

Webhook Receiver

Receive and verify signed webhooks from external systems (Stripe, GitHub, custom).

import { verifyHmacSha256, WebhookQueue } from "datasynx-opencrm/dist/core/webhook-receiver.js";

// Verify HMAC-SHA256 signature (timing-safe):
const ok = verifyHmacSha256(secret, payload, signature);

// Queue-based delivery with dedup:
const queue = new WebhookQueue();
queue.enqueue({ provider: "stripe", payload, signature });

// Stripe-specific verification (checks timestamp tolerance):
import { verifyStripeSignature } from "datasynx-opencrm/dist/core/webhook-receiver.js";
verifyStripeSignature(webhookSecret, rawBody, stripeSignatureHeader);

SSO via WorkOS

Enterprise SSO using WorkOS as the identity provider. Supports SAML and OIDC via any major IdP (Okta, Azure AD, Google Workspace, etc.).

# Required environment variables:
export WORKOS_API_KEY=sk_...
export WORKOS_CLIENT_ID=client_...
export WORKOS_REDIRECT_URI=https://your-app.com/auth/callback
export WORKOS_ORGANIZATION_ID=org_...

import { getSsoAuthorizationUrl, authenticateWithCode, isSsoConfigured }
  from "datasynx-opencrm/dist/core/sso.js";

// Check if SSO is configured:
if (isSsoConfigured()) {
  // Redirect user to IdP:
  const url = getSsoAuthorizationUrl();

  // Exchange code for profile after callback:
  const { profile } = await authenticateWithCode(code);
  // profile = { id, email, firstName, lastName, organizationId }
}

Map SSO user email to DXCRM_ACTOR for RBAC attribution. Combine with dxcrm rbac set <email> <role>.

Security Report

dxcrm security-report
dxcrm security-report --output sec-report.md

Generates a Markdown questionnaire covering: data storage location, authentication, AES-256-GCM encryption at rest, append-only audit trail, network call inventory, GDPR erasure controls, SOC 2 readiness, and dependency management. Useful for procurement and security reviews.

Schema: main_facts.md

---
name: Acme Corp              # required
domain: acme.com
email: ceo@acme.com
phone: "+1 555 0100"
industry: SaaS
relationship_stage: active   # prospect | active | churned | paused
deal_value: 50000
currency: EUR
primary_contact: Alice Smith
timezone: Europe/Berlin
tags: [enterprise, strategic]
created: 2026-01-15
updated: 2026-05-27
---

# Customer: Acme Corp

Any free-form notes here are preserved by update_customer_facts.

Schema: interactions.md

## 2026-05-27 · Call · inbound
**With:** Alice Smith
**Summary:** Discussed Q3 renewal. Budget confirmed at €50k.
**Next Steps:**
- [ ] Send proposal by Friday
- [ ] CC legal team
**Source:** gmail://message/abc123
**Synced:** 2026-05-27T09:14:00Z
---

Entries are newest-first. Written by log_interaction(), summarize_meeting(), and all sync engines. Deduplication via sourceRef prevents re-importing the same email or transcript.

Schema: pipeline.md

# Pipeline — Acme Corp

| Deal | Stage | Value | Currency | Probability | Close Date | Updated | Notes |
|---|---|---|---|---|---|---|---|
| Enterprise License 2026 | negotiation | 75000 | EUR | 75 | 2026-09-30 | 2026-05-27 | Budget confirmed |

Stages are configurable via dxcrm stages set. Default stages: lead · qualified · proposal · negotiation · won · lost.

Full CLI Reference — 69 commands

Full MCP Tool Reference — 82 tools