Frequently Asked Questions

BI tools rely on pre-designed dashboards; Qurify delivers instant analysis through natural language.

• BI tools (Tableau, Power BI) are optimized for visualizing predefined metrics — when a question isn't on the dashboard, you file a request with IT
• Qurify queries and analyzes data instantly with natural language, no upfront design required — business users find answers themselves
• Searches unstructured data (documents, manuals, reports) alongside databases, combining numbers with context
• Acts as a complement to BI, covering ad-hoc analysis and document-driven insights that BI can't reach

ERP AI is limited to the currently open screen; Qurify cross-analyzes across all tables.

• Most ERP AI features can only query data on the currently open screen — tracing root causes means manually opening multiple screens one by one
• Qurify's ontology connects data across tables and screens at the semantic level, so a single natural language question performs cross-analysis and drill-down
• It doesn't replace your ERP — it adds an intelligence layer on top, keeping all core ERP functions exactly as they are

Simple SQL is possible, but enterprise-grade accuracy is another story.

• LLM alone: Must feed the entire schema — accuracy drops sharply past ~50 tables. Can't interpret internal jargon, and guesses join paths leading to wrong results
• Qurify + LLM: The knowledge graph selects only relevant tables and provides pre-verified join paths and business rules, maintaining accuracy at scale
• Creates a structure where the LLM "knows what it doesn't know" — answering only from confirmed information instead of guessing

Qurify doesn't replace your data platform — it adds a 'knowledge layer' on top.

• Schema filtering: The knowledge graph selects only the tables needed for each question — maintaining accuracy at scale
• Join-path verification: Only pre-verified paths are used, with SQL validated before execution
• Federation: Connects multiple databases in a single query across heterogeneous systems
• Hybrid analysis: Combines SQL results and document search results in one answer

The core is data querying and analysis, with the ability to extend into real business execution.

It works in four steps:

1. Interpret — AI processes unstructured inputs (emails, PDFs)
2. Verify — The ontology verifies facts (registered vendor, contract price match, etc.)
3. Execute — Critical work like journal entries and notifications runs through auditable workflows
4. Approve — High-risk items stop at a human approval gate (HITL)

AI assists with ambiguous judgment, but humans keep final control over decisions where money moves.

All major relational databases and cloud data warehouses are supported.

• Relational DBs: PostgreSQL, MySQL, MariaDB, MSSQL, and more
• Cloud DWs: Databricks, Snowflake, Amazon Redshift, etc.
• Document formats: PDF, Word, Excel, PowerPoint, HWP — via file upload or storage integration
• Extensibility: Specialized data sources connect through custom MCP connectors, with supported types continuously expanding

Yes, it connects to every data layer.

• Raw tables, preprocessed/transformed tables, and views are all supported equally
• Multiple layers can be connected simultaneously
• Recommended approach: Start with the processed layer your business teams actually query (views/mart tables), then expand to raw layers as needed — this keeps ontology quality high and minimizes noise

Yes, existing assets can be imported and reused.

• Column aliases and descriptions are collected automatically when connecting to the database
• Synonym dictionaries can be bulk-imported via CSV or registered through the conversational curation tool
• Existing semantic layers, data dictionaries, and standard term glossaries are all supported
• Qurify's two-tier ontology extends them beyond a simple glossary to include relationship inference and join-path verification

Yes, MCP-based architecture enables standardized integration with a wide range of systems.

• Supported systems: SAP, Oracle ERP, Salesforce, plus groupware, internal wikis, and file servers
• Simple setup: Add data sources by configuring an MCP connector — no custom API development needed
• Flexibility: REST APIs and webhooks also supported for systems without MCP support
• Integration scope and approach are designed around your environment during consultation

Yes, DB (SQL) search and document (RAG) search are combined in a single agent.

• Supported formats: PDF, HWP/HWPX, DOCX, XLSX, CSV, TXT, and more
• Documents are split into chunks → vector embedded → semantic search performed
• Hybrid query example: "Pull last quarter's revenue trend from the DB and find the related contract terms from the contract PDF" → returns SQL results and document search results together

No. Qurify builds in stages under the principle that simpler is better.

• Levels 1–2: Map core entities of structured data to standard terminology
• Level 3: Integrate unstructured data (contracts, emails) once value is proven
• Levels 4–5: Move toward self-expansion

Each level goes through 'ping-pong' verification — a back-and-forth on semantic definitions with your team — and is promoted only once fully validated, so you control risk while seeing results fast.

Through a 4-step automated pipeline.

1. Description generation — AI reads table/column metadata from your DB schema and auto-generates natural language descriptions
2. Physical structure mapping — Schema → table → column relationships are structured
3. Existing SQL incorporation — Join patterns and filter conditions from business teams' existing report SQL are integrated
4. Semantic layer extraction — AI analyzes everything to auto-extract synonyms, business rules, domain categories, and join paths

Combining LLM reasoning with knowledge graph constraints keeps hallucinations in check.

The ontology is rebuilt and swapped in atomically — no service interruption.

• Previous customizations (synonyms, business rules) are preserved after rebuild
• Even at hundreds of tables, rebuild finishes in minutes to tens of minutes
• Rebuild cycles can be automated with a scheduler
• Incremental sync (updating only changed parts) is planned for a future release

Yes, the AI uses them right away.

For example, registering 'COGS' as a synonym for a specific column means any question mentioning 'COGS' will be routed to the correct data.

Three ways to register:

• Conversational curation tool — type in natural language (e.g., "COGS means the same as cost_detail.total_amount")
• AI suggestions — review and confirm synonyms the AI proposes during ontology construction
• CSV bulk import — import an existing data dictionary at once

Yes, registering 'example SQL' serves two purposes.

• Ontology strengthening: Join patterns and filter conditions from those queries are analyzed to enrich the knowledge graph
• Pattern learning: When similar questions come in, the same query patterns are referenced
• Accuracy benchmark: Registered example SQL is also used to compare AI-generated SQL results against known-correct results for accuracy measurement

A multi-layered system prevents and corrects errors.

• Source attribution: Every answer includes the original document location or SQL query for direct verification
• Automated evaluation: LLM Judge scores accuracy, evidence fidelity, and completeness in real time — low-confidence answers are flagged
• User feedback: Thumbs up/down continuously improves the ontology and prompts
• Monitoring: Admin dashboard tracks accuracy trends by query and proactively addresses recurring error patterns

This closed-loop structure means answer quality improves the more the system is used.

No fine-tuning. Knowledge lives in the ontology; the LLM is the reasoning tool.

• Commercial LLMs are used on a prompt basis — knowledge is stored in the ontology (knowledge graph)
• SQL generation runs with maximum-determinism settings for consistency
• No fine-tuning dependency means swapping AI models doesn't require rebuilding your ontology assets
• The knowledge graph holds the knowledge; the LLM is the reasoning tool

Exact SQL text isn't guaranteed 100%, but 'result-level' reproducibility is maintained at a high level.

• Minor variations (column order, alias names) can occur due to the nature of AI
• Ontology-based schema filtering and example SQL patterns ensure result consistency
• Reproducibility checks run the same question multiple times and compare outputs
• Generated SQL is also pre-screened for syntax and executability errors

If the question falls within ontology coverage, it answers even without prior examples.

• Within registered tables, columns, and join paths — SQL is auto-generated from ontology information
• Outside coverage — it explicitly states "No related tables found" rather than fabricating an answer
• When new question types arise, adding relevant tables and business terms makes them immediately answerable
• Expanding the ontology = expanding the AI's coverage

As long as join paths are registered in the ontology, accuracy holds even with multi-table joins.

• 3–4+ joins use only pre-verified paths — unregistered join paths are never generated
• Aggregation errors from 1:N relationships (fan-out) are prevented by defining aggregation rules or registering correct SQL patterns
• The key accuracy variable isn't the number of joins — it's whether those join paths have been registered and verified in the ontology

A production environment is built in 3–5 weeks through a standard 5-phase process.

1. Week 1 — Environment setup and data source connection
2. Week 2 — Ontology design and data indexing
3. Week 3 — AI tuning and quality verification
4. Week 4 — Pilot operation and feedback
5. Week 5 — Launch and stabilization

Work that takes 6+ months to develop in-house is dramatically compressed with our proven framework. Timelines adjust for project scale, and we finalize the detailed schedule together at kickoff.

Both options offer identical functionality — choose based on your security policies and operating environment.

• SaaS: No infrastructure needed, ready immediately. SmartMind AI handles all updates and maintenance for minimal operational burden. Best for fast adoption and flexible scaling
• On-Premise: Installs on your own servers or private cloud — data never leaves your network. Recommended for regulated industries (finance, public sector, healthcare)
• Hybrid: Core data on-premise, general documents on SaaS — also fully supported

Enterprise-grade security is built in by default.

• Encryption: AES-256 for data at rest and in transit
• Access control: RBAC regulates access by user, department, and rank
• PII protection: Personally identifiable information is auto-detected and masked before AI answers are generated
• Audit trail: All queries, responses, and data access recorded for compliance
• Authentication: SSO/LDAP integration applies your existing auth system as-is
• Closed network: On-premise deployment supports fully air-gapped operation

Yes, AI models can be swapped freely.

• No fine-tuning dependency: Knowledge lives in the ontology and the LLM is called via prompts — switching models doesn't require rebuilding knowledge assets
• On-premise LLM: If security policies restrict external API calls, deploy an open-source LLM on your own GPU servers for fully closed-network operation
• Any model with OpenAI API-compatible interface connects with a simple endpoint change

Today, Qurify is delivered as an independent web interface separate from your ERP.

• It connects to the ERP database to query data but isn't embedded inside ERP screens
• This is a deliberate design — as an independent system it isn't locked to any ERP, and it can connect multiple systems simultaneously for cross-analysis
• We are exploring embedding Qurify inside ERP screens based on PoCs and production experience, with the ultimate goal of bringing natural language analysis into whatever environment users know best