Frequently asked questions

EnterGenni is enterprise knowledge infrastructure — it gives your enterprise an AI layer, built from your existing systems in a few clicks, without replacing what you already run.

Under the hood, it's 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.

EnterGenni 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. EnterGenni 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 EnterGenni 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. Domain rule packs name relationships (such as REPORTS_TO) deterministically, and you can review every name.

Questions in plain English are a separate feature, below. On the Ask page EnterGenni drafts a read-only Cypher query from your model's schema and checks it, so you can see, edit and copy it. To run it, connect your own database for the session (nothing is stored). Your generated code includes POST api/graph/ask, which drafts with your own LLM key and runs the query only after the same checks, a plan check and inside a read-only transaction. It is off until you switch it on.

The Ask page also has a library of ready-made questions grouped by what you want to know (overview, look-ups, connections, hierarchies, data quality, impact, figures and business intents), a drag-and-drop query designer, and exports to CSV, Excel, JSON, Markdown and Cypher. Connect your own database to run them, or open the same console inside your generated application at api/graph/ask/console.

No. EnterGenni generates an AI layer — 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. To get answers, use Ask: pick a ready-made question, build one by drag and drop, or type it in plain English. No prior Neo4j knowledge is required to generate the layer either. EnterGenni 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 EnterGenni generates, but it's not a prerequisite to get started.

The first three are the original single-system formats; all produce identical output. Review and multi-system linking also read SQL DDL files, CSV column listings, OpenAPI, OData $metadata, Dataverse Web API entity definitions, SAP data dictionary exports (tables and BAPI structures), SAP IDoc definitions and Salesforce describe exports (see the format guide).

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 EnterGenni 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. EnterGenni 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. EnterGenni is designed for that lifecycle:

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

2. Regenerate your AI 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 AI 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.

Yes. After you sign in, Name Review shows every entity, field and relationship from your schema with suggested names. Click a suggestion to accept it or type your own. Names are checked as you go (valid identifiers, no clashes, no reserved words), and the original name is always kept so you can go back.

It is optional: skip it and generate straight from the schema as before.

Two layers. Rules always run: they expand common abbreviations (CSTMR_NM to CustomerName, PH_NO to PhoneNumber), drop prefixes such as tbl_ or dim_, and apply the domain rule books for relationship labels.

On Pro, Enterprise and during the 7-day trial, AI adds suggestions for names the rules cannot read. AI output is validated the same way as your own typing. By default it is only a suggestion and nothing changes until you click it. If you switch on AI auto-apply for a project, AI names at or above the confidence you choose are applied to names nobody has decided yet, each marked in the log and revertible in one click; your own decisions always win. AI requests are limited to 20 per hour per account.

Only metadata: names, types, lengths and relationships of entities and fields, plus the names of other systems when linking. It never receives row data, connection strings or credentials. Requests go to Google's Gemini API using Intrologics' own key; your schema text is treated as data in the prompt, not as instructions. If AI is switched off for your plan or unavailable, the rule suggestions still work.

Yes. Enterprise Linking takes two to eight metadata files, one per system, and reads each in its own format:

• SQL DDL (PostgreSQL, MySQL, SQL Server, Oracle, Supabase, Microsoft Fabric warehouse scripts)
• Excel model, JSON model, CSV column listing
• OpenAPI / Swagger
• OData $metadata (Dynamics 365, SAP Gateway)
• Salesforce sObject describe

Each file can be up to 10 MB; one session holds up to 400 entities in total. You can try it with no signup on the enterprise sandbox.

AS-IS keeps every system's entities exactly as imported, side by side, prefixed with the system name. Nothing is merged. Refined merges entities and fields along the links you accepted (for example Dynamics account, Salesforce Account and legacy TBL_CSTMR_MST become one Customer), keeps the widest length of each merged field, and records in a lineage file which system every field came from.

You choose which picture to generate. You can generate both from the same session.

It compares names after reading them (abbreviations, tbl_/dim_/fact_ prefixes, concatenated words, synonyms such as account, client and customer), then checks whether the fields line up (email, tax id, phone, name) and whether their types are compatible. Every proposed link shows its evidence and a confidence. It is a proposal: nothing is merged until you accept it, and you can reject, rename or revert any link.

It never guesses from names it cannot read. A table it does not recognise simply stays unlinked, so check the unlinked ones.

That is a design case. Names such as TBL_CSTMR_MST, FLD1, [Cust Alt Name] or Entered-By are imported (spaces and symbols are folded into valid names, the original is kept), reserved words like Class or Namespace are handled, and a column named like its own table is renamed rather than breaking the generated code.

Two limits to know: columns that look like foreign keys but have no constraint (CustID) stay plain fields instead of being guessed into relationships, and cryptic names the rules and your reviewers cannot expand will need a name from you.

Yes. Each name, type, length and link decision is an entry in an append-only log: what changed, FROM and TO, who did it, when, and whether it came from a rule, AI, or you. Nothing is overwritten. You can revert one change, or restore the whole session to an earlier step; the undo is itself logged.

The generated ZIP includes the log as LINKS-LOG.md, FIELD-EDITS.md and JSON files, and LINEAGE.md for merged entities, so the review can be audited later.

Migrations repeat the same type problems: money to currency, varchar(8000) into a field that holds 4000. Type Rules let you say it once: pick a source type (and optional length, field or entity patterns), pick the target type, length and what happens when a value does not fit (warn, truncate or fail), and see a live preview of every field that would change. Rules apply in order and are saved to your account; system templates (SQL Server to graph, Oracle NUMBER, Sage-style text and money to Dataverse) can be copied and edited.

You can also edit a single field: name, type and length, each with one-click suggestions. A person's edit always outranks a rule. The generated code carries the lengths and a guard for values that do not fit. EnterGenni generates structure and code; it does not migrate your data.

Yes. The generated graph, APIs, repositories and import bundle cover the whole picture, and the sync covers every system. The main sync method reads a merged entity from its primary (first) system, and each other system gets its own method that fills the fields and relationships only that system supplies. You provide a small key resolver that says which node a row belongs to; the default assumes every system uses the same key. Where several systems supply the same field, the primary system's value is kept. Cross-system links have no foreign key behind them and are left to your application.

Name review, Enterprise Linking, Type Rules and the change log are available on every plan, within each plan's run and entity caps (the caps apply to the picture you generate). AI suggestions are included on Pro and Enterprise, and for every account during its 7-day trial. See pricing.

In your account: the imported schema metadata, the proposals and the decision log. No row data is ever uploaded. They are kept until you ask us to delete them or close your account. See the privacy policy.

Yes, on Pro. On the Ask page you type a question; the schema of your model (labels, properties, relationships, never data) and the question go to the AI, and a read-only Cypher query comes back with a one-line explanation. You see it, edit it and then run it. In your generated application, POST api/graph/ask does the same with your own AI key (Anthropic, OpenAI-compatible or Gemini). It is off until you switch it on.

Every model gets a question library grouped by intent: overview (how much of what), look up (list and find records), connections (follow a relationship and count across it), hierarchies (chains such as reporting lines), data quality (gaps, isolated records, duplicates), impact and reach, figures (totals, averages, ranges) and the business intents of your domain packs. The four-system sample has more than 280 questions; browse them in the sandbox.

Yes. The query designer lets you drag labels, relationships, properties and aggregators (count, count distinct, sum, average, minimum, maximum, list) into a pattern, columns, filters and sort. It writes the query as you build, with filter values passed as parameters. Clicking works as well as dragging.

CSV, TSV, Excel (.xlsx), JSON and Markdown for results, and a Cypher file (with parameters) for the query itself, ready for Neo4j Browser, a notebook or a BI tool. Text that a spreadsheet would treat as a formula is exported as plain text.

Queries are read-only three times over: a guard allows only reading queries over your model's labels, relationships and properties (no writing clauses, procedures or plugin functions), the query must plan before it runs, and it runs in a read-only transaction with a time limit and a 1,000-row cap. The connection details stay in your browser tab and are sent with each run; EnterGenni stores no credentials, queries or results. Use a read-only database user as well. Only databases on the public internet can be reached; for a private network, use the console in your generated application (api/graph/ask/console).

The sandbox is genuinely free, forever, with no signup. The only limitation is that it runs fixed sample models (a ContosoERP single system, and a four-system enterprise of Fabric, Dynamics 365, Salesforce and a legacy app) — 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 fixed pre-generated samples (a single ERP and a four-system enterprise) — no user data is ever submitted.

Review and multi-system sessions are different: they keep your imported schema metadata (names, types, lengths, relationships, never row data) and the log of your decisions in your account, so you can come back, revert and regenerate. See the review section below.

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

EnterGenni 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. EnterGenni 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.

No. Provision on Aura creates a Neo4j Aura instance in your own Aura account, and the generated Deploy/ scripts run the API in your own cloud. You own and pay for everything; EnterGenni keeps no keys, passwords or data.

On Pro: paste an Aura API key, choose your Aura project, name, size, cloud and region, and EnterGenni asks Aura to create the instance. The password is shown to you once. When the instance is running, one click applies your model's constraints and indexes (safe to repeat). The key, the short-lived token and the password pass through a single request and are never stored.

Every ZIP on Starter and above includes a Deploy/ folder: Aura provisioning for Bash and PowerShell, a Dockerfile, Docker Compose, Google Cloud Run (password in Secret Manager) and Azure Container Apps (password as a container app secret). Settings are plain environment variables, so other platforms work the same way.

Yes, on Pro. Ontology/ontology.json lists concepts and every relationship with the rule that named it, and Ontology/ontology.ttl is the same model as an OWL 2 ontology in Turtle: classes for labels, datatype properties with XSD types, object properties with domains, ranges and inverses. It loads into Protégé, triple stores and catalogue tools.

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.