Frequently asked questions

AutoGraphDB is a Knowledge Graph Compiler. It reads your relational schema (SQL export, Excel model, or JSON), validates the domain model, runs 16 generation passes, and packages 100+ artifacts — repositories, REST APIs, TypeScript SDK, sync services, FK-derived traversals, import bundle, schema evolution, and deployment report.

It doesn't stop at day one: when your model changes, you regenerate to evolve the platform with schema diffs and updated sync patterns — so adoption starts fast and stays scalable.

AutoGraphDB is built for organizations facing the AI-era data shift:

• Domain-leading enterprises whose competitive edge was built on relational systems and now need graph-native intelligence for AI, RAG, and agent workflows.

• CTOs and architects who must add a graph backbone without rewriting the business or migrating production databases.

• Data and platform teams standing up knowledge graphs, impact analysis, and relationship-aware retrieval.

• Consultancies delivering repeatable graph transformation for clients at scale.

Import and ETL tools load data into a graph database. AutoGraphDB compiles the entire platform — repositories, sync services, REST APIs, TypeScript SDK, FK-derived traversals, schema evolution, and deployment artifacts.

If you only need a one-time CSV load, an importer may suffice. If you need a deployable graph application your teams can run and evolve, you need the platform AutoGraphDB produces.

No. Traversals are generated from your foreign keys and collection relationships — impact analysis, shortest path, hierarchy walks, per-entity traversals, and orphan detection. Semantic flows (purchase lifecycle, approval chains, customer journey) are not inferred unless explicitly modeled in your schema.

Natural language to Cypher (e.g. "show everyone reporting to Sarah") is not in current output — it is roadmap. Your applications or AI layer map business questions to the generated REST APIs and traversals.

No. AutoGraphDB generates a knowledge graph platform — it does not connect to, migrate, or modify your existing database. Optional sync services and seeders are code you deploy and control. Your current systems stay unchanged; the relationship intelligence layer is added when you choose.

No prior Neo4j knowledge is required to generate the layer. AutoGraphDB produces all the Cypher (constraints, indexes, seeders, queries) for you. The run report explains each component. Basic Cypher familiarity is helpful when you want to write your own graph queries on top of what AutoGraphDB generates, but it's not a prerequisite to get started.

Three formats, all producing identical output:

1. Excel sheet (.xlsx) — the guided template with one row per entity (entity name, fields, feature/module). Download the sample from the sandbox.

2. JSON model — a simple array of {"entity","fields","feature"} objects posted to POST /api/generate/graph. Ideal for CI/CD pipelines.

3. SQL Server database — provide a connection string and AutoGraphDB reads the live schema, inferring FK relationships from sys.foreign_key_columns. (Pro and Enterprise plans.)

In the Fields column, write the related entity type followed by the field name: Department Department. This becomes a HAS_DEPARTMENT graph relationship.

For multiple FKs to the same entity (e.g. self-references or two managers), suffix the field name: Employee Employee_Manager → HAS_MANAGER. AutoGraphDB uses the suffix to generate unambiguous relationship names.

For collection traversals (one-to-many), append a pipe and list child entities: string Name, … |Team,Designation. This generates incoming HAS_DEPARTMENT traversal queries on the owning entity.

See the full format guide for examples with the sample sheet.

The engine has been tested on schemas with over 237 entities and 14+ relationship types. For schemas above ~50 entities, use the async job API (POST /api/jobs/graph) — it accepts, validates, queues the job, and returns a job ID you poll for completion. There is no timeout for queued jobs.

Your relational model will change — new tables, renamed FKs, expanded relationships. AutoGraphDB is designed for that lifecycle:

1. Update your model (Excel, JSON, or a fresh SQL export).

2. Regenerate the graph layer.

3. Apply generated schema diff artifacts and updated sync services to evolve Neo4j incrementally.

This turns graph adoption from a one-time project into an ongoing, scalable backbone — aligned with how your business domain actually grows.

Every ZIP includes REST APIs (OpenAPI/Swagger), Cypher schema and queries, a TypeScript client, sync services, and a native import bundle. Connect from your existing backend, data platform, or AI pipeline via HTTP or Neo4j drivers — the graph layer sits alongside your relational source of truth.

Neo4j 5.x, Community or Enterprise. The native import bundle includes a docker-compose.yml for Neo4j 5 + APOC. Constraints and indexes use Neo4j 5 syntax. Neo4j 4.x is not officially supported (constraint syntax differs).

Every generation includes a self-contained HTML report (also available as Markdown) that contains:

• A summary card with entity count, file count, component count, and relationship count.

• A validation issues table listing any warnings caught during generation.

• A collapsible drill-down of every generated file — what it is, where it goes in your project, and how to use it.

• A per-entity breakdown and a next-steps checklist.

The report is included in the downloaded ZIP as RUN-REPORT.html and RUN-REPORT.md.

Yes. The API is a standard REST/JSON interface. A typical CI step is:

curl -X POST .../api/generate/graph -H "Content-Type:application/json" -d @model.json -o graphdb.zip

For async (large schemas): submit a job, poll GET /api/jobs/{id} until status=Succeeded, then download. The Swagger UI documents all endpoints interactively.

The sandbox is genuinely free, forever, with no signup. The only limitation is that it runs the fixed ContosoERP sample model — you cannot upload your own model without a Pro account. This is intentional: it lets you evaluate the full quality of the output (all 68+ files) before committing.

Annual billing saves 25% compared to monthly. The discount is applied automatically when you select the annual toggle at checkout. You pay upfront for 12 months and the annual price is locked for the subscription term.

Yes, at any time. Contact the sales team and we'll prorate the transition. Enterprise requires a custom agreement covering your deployment model, SLA, and any data residency requirements.

Yes. We offer reduced rates for early-stage startups (under 2 years old, under $1M ARR), students with a valid .edu email, and registered non-profit organizations. Contact us with a brief description and we'll reply within one business day.

For synchronous generation (/api/generate/graph): your model is processed in memory and the ZIP is returned. Nothing is written to disk and nothing is retained after the response is sent.

For async jobs (/api/jobs/graph): the model and the generated ZIP are held in-memory until you download the result or the job expires (1 hour). They are then deleted. No database persistence occurs.

The sandbox uses a fixed pre-generated sample — no user data is ever submitted.

No. Your model and generated output are never shared, sold, or used for training data. See the full privacy policy for details.

AutoGraphDB uses only essential cookies (session state, security tokens) and a single preference cookie to remember your cookie consent choice. We do not use advertising, tracking, or third-party analytics cookies. See the full cookie policy.

Yes. AutoGraphDB is designed with data minimization as a core principle: we collect only what's necessary to operate the service and retain it for the shortest practical time. Sandbox and synchronous API calls collect no personal data at all. For account holders, we store only your email address and billing information. Enterprise customers can negotiate data residency (EU-only hosting) for full compliance with their DPA. See the privacy policy for the full picture.

• Sandbox / free tier: the How it works guide covers the most common issues. If you're stuck, email us and we'll reply as soon as we can (no SLA on free tier).

• Pro: email support with a 1 business day response guarantee.

• Enterprise: 4-hour response SLA + dedicated Slack/Teams channel + assigned onboarding engineer.

Yes, on the Enterprise plan. The generation engine ships as a standard Linux container image (no external network calls at generation time). We deliver it to your private registry and provide deployment documentation for Kubernetes, Docker Compose, or bare metal. Contact sales for details.

Not currently. The generation engine is proprietary. The output — all generated graph artifacts you download — belongs entirely to you with no license restrictions. You can use, modify, redistribute, and sell the generated code without attribution.