Frequently asked questions

Neo Graphs is a SaaS code generation engine that takes your relational entity model (an Excel sheet, a JSON payload, or a live SQL Server schema) and produces a complete, production-ready Neo4j graph layer for your .NET application.

In one API call you receive typed C# repositories, REST and MVC controllers, a SQL→graph sync service, Cypher schema, dependency-ordered seeders, insight queries, a TypeScript client, architecture diagrams, a native import bundle, and a detailed HTML run report — all zipped and ready to drop into your project.

Neo Graphs is designed for:

• .NET / C# teams building ERP or enterprise applications who want to add graph database capabilities without rewriting their existing SQL layer.

• Enterprise architects migrating or extending large relational schemas (100–300+ entities) to Neo4j.

• AI / ML teams who need a knowledge graph on top of their relational data for RAG, recommendation engines, or impact analysis.

• Consultants and agencies who deliver Neo4j projects and want to eliminate weeks of boilerplate.

No. Neo Graphs generates code — it does not connect to, migrate, or modify your existing SQL database. The generated sync services and seeders are code you deploy and control. Your EF/SQL layer continues to work exactly as before; the graph layer is added alongside it.

No prior Neo4j knowledge is required to generate the layer. Neo Graphs 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 Neo Graphs 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 Neo Graphs 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. Neo Graphs 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.

Generated C# code targets .NET 6, 7, or 8 (async/await, nullable reference types, minimal API patterns). The Neo4j repositories use the official Neo4j .NET Driver 5.x with async session management. The MVC controllers follow standard ASP.NET Core conventions and integrate with the built-in DI container.

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.

Neo Graphs 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. Neo Graphs 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 the C#, TypeScript, Cypher, and configuration files you download — belongs entirely to you with no license restrictions. You can use, modify, redistribute, and sell the generated code without attribution.