Description:FIELD OF THE INVENTION
The present invention relates to the field of natural language processing (NLP) and data integration. More particularly, it relates to a system and method to convert natural language intent into structured data queries; for enterprise data integration using large language models (LLMs) powered interface that semantically map user intent expressed in natural language to structured data queries across disparate systems.

BACKGROUND
In modern enterprises, large amounts of data are distributed across multiple systems such as project management tools, human resource [HR] databases, code repositories, and other structured data sources. While these systems store critical information, retrieving specific data from them is often a complex task as it requires an understanding of database structures, query languages, and application programming interface [APIs], which are typically within the expertise of technical users or data analysts. For non-technical users, who intend to access this data is not always straightforward. They often need to rely on dedicated teams in order to extract the required information, which further leads to dependency and delays in decision-making. Even for routine queries, the process can become time-consuming, which further affects the overall productivity. Despite advancements in technology, the gap between natural language understanding and structured data retrieval remains a challenge, making it difficult for enterprises to fully utilize their data resources in an efficient and seamless manner.
In order to make data retrieval easier, various solutions have been introduced. Some of the businesses use predefined query templates or dashboard interfaces, wherein the users can select from a set of available options. While these methods offer convenience, they are not flexible and also require prior setup. Other approaches include artificial intelligence-powered chatbots that try to interpret user queries, but they often struggle to understand database structures, thereby providing incorrect or incomplete results. It is also observed that some of the enterprises use Business Intelligence (BI) tools for data analysis, but these systems are complex, expensive, and also require specialized training to operate effectively.
Most of the existing systems make it difficult for non-technical users to retrieve data because they either require technical knowledge or lack the flexibility to handle different types of queries. Some advanced artificial intelligence-powered solutions have been introduced to address this challenge, but they often rely on fixed mappings and predefined rules; referring to the fact that they can only work well with specific data structures and later struggle to adapt when dealing with different enterprise systems. The available schema-based query builders allow users to manually map their queries to relevant data fields. While it provides more control, it still requires an understanding of how databases are structured, eventually making it difficult for the users without technical expertise, thereby making it reliant on Information Technology [IT] teams or data specialists in order to access the information they require, which leads to delays and inefficiencies in business operations.
Prior arts:
CN109255113B discloses an intelligent proofreading system that integrates artificial intelligence techniques, including natural language processing, voice recognition, voice synthesis, and optical character recognition [OCR] recognition; enables text proofreading through a text proofreading module, which is later on assisted by voice synthesis and the OCR modules to handle various input formats, such as text, voice, and images; thereby enhancing the proofreading process by increasing efficiency and reducing manual workload.
The existing systems for retrieving data from enterprise databases mostly depend on fixed rules, predefined mappings, or complex configurations, thereby making them difficult for non-technical users to operate. These systems often require specialized knowledge of database structures, which leads to dependency on technical teams and delays access to important information. Moreover, many of these solutions lack flexibility, as they are designed to work with only specific types of databases or require manual setup, which again makes it challenging to process different types of queries across multiple systems. Therefore, there is a need for a simpler and more adaptable system that allows users to retrieve data effortlessly by describing what they need in their own words, which most importantly shall work without requiring any knowledge of database languages or structures.
The present invention thus provides a system that overcomes these challenges by understanding user intent expressed in natural language and converting it into structured queries that can retrieve data from different enterprise systems.

DEFINITIONS:
The expression “system” used hereinafter in this specification refers to an ecosystem comprising, but not limited to, a natural language intent into structured data conversion system with input and output devices, processing unit, plurality of mobile devices, a mobile device-based application. It is extended to computing systems like mobile phones, laptops, computers, PCs, and other digital computing devices.
The term “input unit” used hereinafter in this specification refers to, but is not limited to, mobile, laptops, computers, PCs, keyboards, mouse, pen drives or drives.
The term “processing unit” refers to the computational hardware or software that performs the database analysis, generation of graphs, detection of dead code, processing, removal of dead code, and like. It includes servers, CPUs, GPUs, or cloud-based systems that handle intensive computations.
The term “output unit” used hereinafter in this specification refers to hardware or digital tools that present processed information to users including, but not limited to computer monitors, mobile screens, printers, or online dashboards.
“Enterprise systems” used hereinafter in this specification refers to various structured data sources, including project management tools, HR databases, and code repositories, that store and manage critical business information.
“Query languages” used hereinafter in this specification are programming languages which are used to retrieve and manipulate data from structured databases, which typically require technical expertise to construct and execute queries.
“Schema-based query builder” used hereinafter in this specification refers to a system where users manually map their queries to specific data fields within a database structure, requiring prior knowledge of database schemas for accurate data retrieval.
“Semantic mapping engine” used hereinafter in this specification is a component that analyzes user intent expressed in natural language and aligns it with structured database schemas, enabling accurate and efficient data retrieval.
“Application programming interface (API)” used hereinafter in this specification is a set of defined rules and protocols that allows different software systems to communicate with each other, facilitating data exchange between enterprise systems and external applications.
“Intent-to-data interface” used hereinafter in this specification is a system designed to interpret user intent in natural language and convert it into structured queries, allowing seamless access to enterprise data without requiring knowledge of database query languages.
The term “Large Language Models” or “LLMs” used hereinafter in this specification refers to an advanced computational model employed by the system to perform generic inferencing tasks. The LLMs serve as the core processing engines to identify the intents and attributes of incoming requests and are trained to understand and generate natural language and code, used here to analyze and identify dead code.
The term “vector similarity” used hereinafter in this specification refers to a subset of machine learning, where the system measures how similar two pieces of data are — once they are represented as vectors i.e. numerical arrays; such that when a natural language input or document is turned into a list of numbers (referred to as a vector); and the two vectors are "close together" in a high-dimensional space, the original texts/inputs are considered similar. Furthermore, the vector similarity is used in, but not limited to, search engines (e.g., finding similar documents or questions), recommendation systems or LLM-based Retrieval-Augmented Generation (RAG).
The term “normalized view” used hereinafter in this specification refers to a view that relates all source systems and maps them to a similar structure; for example - looking at customer issues and code to relate the intent, source, change, etc.
The term “vector embedding” used hereinafter in this specification refers to a way to represent complex data including, but not limited to words, sentences, documents or images as a list of numbers also referred to as a vector in a multi-dimensional space; wherein similarities in meaning or structure correspond to similar vectors.
The term “SQL (Structured Query Language)” used hereinafter in this specification refers to a standard language for storing, manipulating, retrieving data in database and managing relational databases that enables the storage, retrieval, updating, entry, and analysis of data in tables.
The term “GraphQL” used hereinafter in this specification refers to an open-source data query and manipulation language for APIs and a runtime for executing and fulfilling queries with existing data.
The term “REST API” used hereinafter in this specification refers to REpresentational State Transfer API, which is a type of API that allows communication between different systems over the internet; that work by sending requests and receiving responses, typically in JSON format, between the client and server.

OBJECTS OF THE INVENTION:
The primary objective of the present invention is to provide a system and method to convert natural language intent into structured data queries; for enterprise data integration.
Another object of the invention is to provide an LLM-powered intent-to-data interface that enables users to retrieve structured data using natural language, without requiring technical expertise.
Another objective of the invention is to eliminate dependency on technical users by allowing direct access to enterprise data without the need for understanding database schemas or query languages.
Yet another objective of the invention is to ensure accurate data retrieval by using a semantic mapping engine in order to correctly interpret user intent and generate precise queries.
Yet another objective of the invention is to enhance flexibility and accessibility by enabling compatibility across different enterprise systems and database structures.
An additional objective of the invention is to streamline the workflow and improve efficiency by reducing the delays in retrieving relevant data.

SUMMARY:
Before the present invention is described, it is to be understood that the present invention is not limited to specific methodologies and materials described, as these may vary as per the person skilled in the art. It is also to be understood that the terminology used in the description is for the purpose of describing the particular embodiments only and is not intended to limit the scope of the present invention.
The present invention discloses a system and method to convert natural language intent into structured data queries; for enterprise data integration using large language models (LLMs) powered interface that semantically map user intent expressed in natural language to structured data queries across disparate systems; comprising of user, an input device, input, a processing unit, output, and an output device, an input interface, an intent parser, a mapping engine, a schema registry, a query generator, an internal API gateway, a post-processing engine, a feedback engine and an output interface working in sequential interaction.
In an aspect of the invention, the input interface accepts natural language queries entered by the user, an LLM-powered intent parser that extracts structured entities, conditions, and targets, a semantic mapping engine aligns intent to real data schema fields using learned representations and embeddings, a data schema registry holds normalized views of all source systems, a query generator dynamically composes various types of queries, an internal API gateway secures and standardizes access to structured data, a post-processing layer converts raw data into usable formats, a final output interface displays structured and conversational results.
In another aspect, the system and method of present invention may be used in enterprise intelligence systems, conversational analytics, agent-based automation in relation to program management, software engineering workflows, HR decision support or customer success operations, and is not limited to it.

BRIEF DESCRIPTION OF DRAWINGS:
A complete understanding of the present invention may be made by reference to the following detailed description which is to be taken in conjugation with the accompanying drawing. The accompanying drawing, which is incorporated into and constitutes a part of the specification, illustrates one or more embodiments of the present invention and, together with the detailed description, it serves to explain the principles and implementations of the invention.
Fig. 1. illustrates the components of the system to convert natural language intent into structured data queries.
Fig. 2. illustrates the sequential arrangement of the various modules of the system of the present invention.
Fig. 3. illustrates a stepwise method to convert natural language intent into structured data queries.

DETAILED DESCRIPTION OF INVENTION:
Before the present invention is described, it is to be understood that this invention is not limited to methodologies described, as these may vary as per the person skilled in the art. It is also to be understood that the terminology used in the description is for the purpose of describing the particular embodiments only and is not intended to limit the scope of the present invention. Throughout this specification, the word “comprise”, or variations such as “comprises” or “comprising”, will be understood to imply the inclusion of a stated element, integer or step, or group of elements, integers or steps, but not the exclusion of any other element, integer or step, or group of elements, integers or steps. The use of the expression “at least” or “at least one” suggests the use of one or more elements or ingredients or quantities, as the use may be in the embodiment of the invention to achieve one or more of the desired objects or results. Various embodiments of the present invention are described below. It is, however, noted that the present invention is not limited to these embodiments, but rather the intention is that modifications that are apparent are also included.
The present invention discloses a system and method to convert natural language intent into structured data queries; for enterprise data integration using large language models (LLMs) powered interface that semantically map user intent expressed in natural language to structured data queries across disparate systems. The present system (100) comprises a user (10), an input device (20) input (25), a processing unit (30), output (35) and an output device (40), wherein the processing unit (30) further comprises of an input interface (110), an intent parser (120), a mapping engine (130), a schema registry (140), a query generator (150), an internal API gateway (160), a post-processing engine (170), a feedback engine (180) and an output interface (190) arranged sequentially such that the system works in sequential interaction of these structural components of the system.
According to an embodiment of the invention, the input interface (110) accepts user (10) queries in the form of a “natural language input” (25), whereby query or queries are allowed in the form of voice input, chat or free text input or an API-based input, but not limited to it, provided using atleast one input device (20). The natural language input (25) provided by the user (10) who may not necessarily know the specific field names or systems.
According to another embodiment of the invention, the intent parser (120) based on large language modules (LLMs), allows extraction of intent from the input query (25) into a structured representation of actions, filters, entities, conditions, and targets. The intent parser uses few-shot prompting or fine-tuning to robustly interpret variations in phrasing of the natural language input (25) thereby using contextual understanding to resolve ambiguous or fuzzy language which is adaptable to new systems without re-programming.
According to yet another embodiment of the invention, the mapping engine (130) maps the parsed terms to normalized schema including parameters not limited to, contributor, last quarter, date range and like, wherein the engine (130) understands schema-level mappings between user language and structured fields using LLM, either based on vector similarity wherein the system measures the similarities between two vectors that represent two different inputs respectively, or prompt-based reasoning wherein the LLMs respond to prompts by applying logic, memory, and general knowledge within the structure of the prompt; that includes understanding the intent behind the prompt, using contextual clues to deduce or infer, or combining knowledge from training and prompt. The mapping engine (130) thereby allows rapid matching of user intent to data fields to resolve ambiguity, and supports learning from example queries and feedback thereby adapting to new schemas and fields over time.
According to yet another embodiment of the invention, the schema registry (140) holds normalized views of all source systems, wherein the registry (140) indexes data fields with vector embeddings and metadata, supporting rapid semantic search and auto-completes the lookup. The metadata is the centralized storage from all connected systems including but not limited to field names, types, descriptions or sample values.
According to yet another embodiment of the invention, the query generator (150) dynamically converts structured intent by automatically applying filters and transformations, into system-specific queries by including but not limited to SQL queries for databases, GraphQL query for semantic APIs, or REST for legacy integrations. The said query generator (150) generates valid queries on-the-fly for different systems and interfaces thereby auto-optimizing the system performance and filtering. Further, the internal API gateway (160) converts internal queries into function-call-ready APIs; and enables interoperability between LLMs and structured data. The gateway (160) further secures and standardizes backend access to structured data; wherein the API gateway (160) acts as an abstraction layer that allows rate limiting, role-based access control (RBAC), multi-tenant API management and auditing so as to control the incoming request by pre-defined criteria like subscription or region; thereby enabling reusable access of the generated endpoints for future AI agents.
According to a next embodiment of the invention, the post-processing engine (170) enhances raw data by sorting, summarizing, adding human-readable explanations when requested by the user and finally converting the raw data into system usable formats such as markdown, JSON, or visual formats such as graphs, charts, flowcharts or diagrams. Further, the feedback engine (180) enables a feedback mechanism to refine intent-to-query accuracy; wherein if the system misinterprets intent or schema, the user can refine the query and learns from the user edits corrections, confirmation or failures thereby improving the system over time.
According a further embodiment of the invention, the output interface (190) allows user interaction through a visual format wherein the system delivers results or output (35) by providing structured and conversational results through atleast one output device (40), thus delivering results into computer readable visual formats either to the chatbots that show results as messages (markdown in readable format), web UIs that’s displays visual widgets such as interactive charts and tables or LLM agent or API response that provides a structured file format such as .JSON.
According to a preferred embodiment of the invention, the processing unit employs a method as illustrated in Fig. 3., to convert natural language intent into structured data queries; for enterprise data integration using large language models (LLMs) powered interface. The method comprises the steps as follows:
- Initiating the system by the user (10);
- providing an input query (25) by the user (10) as a “natural language input” (25) in the form of voice input, chat or free text input, or API-based input;
- accepting input query (25) by the input interface (110);
- extraction of intent from the query input (25) into structured representation of actions, filters, entities, conditions, or targets; by the LLM- based intent parser (120) which uses few-shot prompting or fine-tuning to robustly interpret variations in phrasing of the natural language input (25) thereby using contextual understanding to resolve ambiguous or fuzzy language;
- mapping the parsed terms to normalized schema including parameters such as contributor, last quarter or date range by the mapping engine (130) which understands schema-level mappings between user language and structured fields using LLM;
- resolving ambiguity by the mapping engine (130) based on vector similarity or prompt-based reasoning allowing rapid matching of user intent to data fields;
- indexing data fields and metadata by the schema registry (140) thereby supporting rapid semantic search and auto-completing the lookup;
- converting structured intent by automatically applying filters and transformations, into system-specific queries by the query generator (150) thereby generating valid queries on-the-fly for different systems and interfaces thereby auto-optimizing the system performance and filtering;
- securing and standardizing backend access to structured data using the internal API gateway (160) thereby converting internal queries into function-call-ready APIs, enabling interoperability between LLMs and structured data;
- enhancing raw data by sorting, summarizing, adding human-readable explanations using the post-processing engine (170) when requested by the user
- converting the raw data into system usable formats such as markdown, .JSON, or visual formats such as graphs, charts, flowcharts or diagrams;
- enabling a feedback mechanism using the feedback engine (180) to refine intent-to-query accuracy; where user can refine the query and learns from the user edits, corrections, confirmation or failures thereby improving the system over time;
- allowing user interaction and delivering results using the output interface (190) in visual formats either using the chatbots that show results as messages (markdown in readable format), the web UIs that displays visual widgets or LLM agent or API response that provides a structured file format.
According to a next embodiment, the present system and method may be used in enterprise intelligence systems, conversational analytics, agent-based automation in relation to program management, software engineering workflows, HR decision support or customer success operations, and is not limited to it.

Working Example:
In an exemplary scenario where a Project Manager wants to analyze the top-performing developers who contributed to an AI-related project last quarter. The manager has no SQL or API expertise and simply enters the request using natural language. The stepwise method executed by the system is as follows:
1. Providing input in natural language into the input interface:
The project manager submits a query in form of free text or natural language, using a chatbot on the screen:
"Who were the top developers working on the AI project last quarter?"

2. Extraction of intent by the intent parser:
The LLM-powered Intent Parser extracts structured details using the parameters:
o Entity: Developer
o Action: Retrieve top contributors
o Filters: project = AI, time = last quarter

3. Mapping the parsed terms semantically by the mapping engine:
The parsed terms are mapped to the schema registry:
o "Developers" → git_commit.author
o "AI project" → project_name = 'AI'
o "Last quarter" → date_range (Jan–Mar)
If the user query contains ambiguous terms (e.g., “top”), the system resolves ambiguity using vector similarity or prompts.

4. Indexing data fields and metadata by the schema registry:
The Schema Registry contains metadata for multiple systems:
o HR System: Employee names, performance ratings
o Code Repository: Git commits, project contributions
o Project Management Tool: Assigned tasks, milestones
The system identifies relevant fields for the query:
o Git Contributions: commit_count, lines_added
o HR Records: performance_score
o Project Data: task_completion_rate

5. Converting structured intent into system-specific queries by the query generator:
The system automatically composes an optimized query:
SQL Query for Code Repository:
Converts "top 3 contributors in Q1" → SQL with ORDER BY and LIMIT 3

6. Securing and standardizing backend access to structured data using the internal API gateway:
The API Gateway enforces role-based access control (RBAC):
o The Project Manager has access to code contributions but not salaries.
o If a Finance Team Member requested salary data, access would be denied.
The API standardizes and secures the requests across different enterprise systems.

7. Enhancing raw data using the post-processing engine:
The system formats results into a structured, user-friendly report:
o Sorts and ranks top contributors
o Converts raw data into charts/table
o Adds natural language explanations
For the sake of this example, the system displays a list of top 3 Developers in AI Project (Jan–Mar 2024):
1. Developer X:
85 commits; 12,500 lines added; Performance Score: 9.2/10
2. Developer Y:
70 commits; 9,800 lines added; Performance Score: 8.7/10
3. Developer Z:
65 commits; 8,900 lines added; Performance Score: 8.5/10

8. Enabling a feedback mechanism using the feedback engine:
If the system misinterprets intent or schema, the user can refine the query, and learns from the corrections and improves over time.
The manager provides feedback: "Include only senior developers."
System Adjusts Query to filter by seniority (role = 'Senior Developer').

9. Allowing user interaction and delivering results using the output interface:
The output interface displays .JSON Output for AI Agents:
{
"developers": [
{"name": "Developer X", "commits": 85, "lines_added": 12500, "performance_score": 9.2},
{"name": "Developer Y", "commits": 70, "lines_added": 9800, "performance_score": 8.7},
{"name": "Developer Z", "commits": 65, "lines_added": 8900, "performance_score": 8.5}
]
}
While considerable emphasis has been placed herein on the specific elements of the preferred embodiment, it will be appreciated that many alterations can be made and that many modifications can be made in preferred embodiment without departing from the principles of the invention. These and other changes in the preferred embodiments of the invention will be apparent to those skilled in the art from the disclosure herein, whereby it is to be distinctly understood that the foregoing descriptive matter is to be interpreted merely as illustrative of the invention and not as a limitation.
, Claims:CLAIMS:
We claim,
1. A system and method to convert natural language intent into structured data queries; for enterprise data integration;
wherein the system (100) comprises a user (10), an input device (20) input (25), a processing unit (30), output (35) and an output device (40), wherein the processing unit (30) further comprises of an input interface (110), an intent parser (120), a mapping engine (130), a schema registry (140), a query generator (150), an internal API gateway (160), a post-processing engine (170), a feedback engine (180) and an output interface (190) arranged sequentially such that the system works in sequential interaction of these structural components of the system;

characterized in that:
the input interface (110) accepts user (10) queries in the form of a “natural language input” (25) using atleast one input device (20);

the intent parser (120) based on large language modules (LLMs), allows extraction of intent from the input query (25) into a structured representation of actions, filters, entities, conditions, and targets;

the mapping engine (130) maps the parsed terms to normalized schema including various parameters, understands schema-level mappings between user language and structured fields using LLM, based on vector similarity or prompt-based reasoning allowing rapid matching of user intent to data fields to resolve ambiguity;

the schema registry (140) indexes data fields with vector embeddings and metadata, supporting rapid semantic search and auto-completes the lookup; and holds normalized views of all source systems;

the query generator (150) dynamically converts structured intent by automatically applying filters and transformations, into system-specific queries; for different systems and interfaces thereby auto-optimizing the system performance and filtering;
the internal API gateway (160) converts internal queries into function-call-ready APIs, enables interoperability between LLMs and structured data, secures and standardizes backend access to structured data;

the post-processing engine (170) enhances raw data when requested by the user, converting it into system usable formats visual formats;

the feedback engine (180) enables a feedback mechanism to refine intent-to-query accuracy; and learns from the user edits corrections, confirmation or failures thereby improving the system over time;

the output interface (190) allows user interaction through a visual format wherein the system delivers results or output (35) by providing structured and conversational results through atleast one output device (40), delivering results into computer readable visual formats.

2. The system as claimed in claim 1, wherein the natural language input (25) queries are allowed in the form of voice input, chat or free text input or an API-based input.

3. The system as claimed in claim 1, wherein the intent parser (120) uses few-shot prompting or fine-tuning to robustly interpret variations in phrasing of the natural language input (25) thereby using contextual understanding to resolve ambiguous or fuzzy language which is adaptable to new systems without re-programming.

4. The system as claimed in claim 1, wherein the registry (140) uses the metadata which is a centralized storage from all connected systems including but not limited to field names, types, descriptions or sample values.

5. The system as claimed in claim 1, wherein the system-specific queries generated by the query generator (150) includes, but is not limited to SQL queries for databases, GraphQL query for semantic APIs, or REST for legacy integrations.

6. The system as claimed in claim 1, wherein the API gateway (160) acts as an abstraction layer that allows rate limiting, role-based access control (RBAC), multi-tenant API management and auditing so as to control the incoming request by pre-defined criteria; thereby enabling reusable access of the generated endpoints for future AI agents.

7. The system as claimed in claim 1, wherein the post-processing engine (170) enhances raw data by sorting, summarizing, adding human-readable explanations; and converts the raw data into system usable formats such as markdown, JSON, or visual formats such as graphs, charts, flowcharts or diagram.

8. A method employed by the processing unit to convert natural language intent into structured data queries; for enterprise data integration comprises the steps as follows:
- Initiating the system by the user (10);
- providing an input query (25) by the user (10) as a “natural language input” (25) in the form of voice input, chat or free text input, or API-based input;
- accepting input query (25) by the input interface (110);
- extraction of intent from the query input (25) into structured representation of actions, filters, entities, conditions, or targets; by the LLM- based intent parser (120) using few-shot prompting or fine-tuning to robustly interpret variations in phrasing of the natural language input (25);
- mapping the parsed terms to normalized schema by the mapping engine (130) which understands schema-level mappings between user language and structured fields using LLM;
- resolving ambiguity by the mapping engine (130) based on vector similarity or prompt-based reasoning allowing rapid matching of user intent to data fields;
- indexing data fields and metadata by the schema registry (140) thereby supporting rapid semantic search and auto-completing the lookup;
- converting structured intent by automatically applying filters and transformations, into system-specific queries by the query generator (150) thereby generating valid queries for different systems and interfaces;
- securing and standardizing backend access to structured data using the internal API gateway (160) thereby converting internal queries into function-call-ready APIs;
- enhancing raw data by sorting, summarizing, adding human-readable explanations using the post-processing engine (170) when requested by the user
- converting the raw data into system usable formats such as markdown, .JSON, or visual formats such as graphs, charts, flowcharts or diagrams;
- enabling a feedback mechanism using the feedback engine (180) to refine intent-to-query accuracy; where user can refine the query and system learns from the user edits, corrections, confirmation or failures thereby improving the system over time;
- allowing user interaction and delivering results using the output interface (190) in visual formats either using the chatbots, web UIs, LLM agent or API response.

Dated this 11th day of April, 2025.