Building Intelligent Data Agents: Unleashing NL2SQL with Semantic Kernel

vikaspandey

Microsoft

May 28, 2025

The landscape of data interaction is rapidly evolving, moving beyond traditional structured queries towards more intuitive, natural language-driven approaches. At the forefront of this transformation lies Semantic Kernel (SK), a powerful open-source SDK from Microsoft that empowers developers to build intelligent applications by seamlessly integrating Large Language Models (LLMs).

In this blog post, we'll explore how Semantic Kernel can be leveraged to create sophisticated Natural Language to SQL (NL2SQL) solutions. We'll delve into the key features of Semantic Kernel that make this possible, including its powerful agent collaboration features and the plugin architecture for defining semantic functions. Drawing inspiration from the attempted workflows in code experiments, we'll illustrate a practical multi-agent NL2SQL pipeline.

The Promise of Natural Language to SQL

NL2SQL aims to democratize data access by allowing users to query databases using plain English. This eliminates the need for specialized SQL knowledge, opening up valuable insights to a broader audience and streamlining data retrieval for everyone.

Semantic Kernel: The Foundation for Intelligent Agents

Semantic Kernel provides the essential building blocks for creating intelligent agents that can understand and act upon natural language. Its core features are instrumental in constructing robust NL2SQL solutions:

Pluggable AI Connectors: Semantic Kernel offers seamless integration with various LLM providers (e.g., Azure OpenAI, OpenAI), abstracting away the complexities of API interactions. This allows developers to focus on the core logic of their applications.
Plugins: Encapsulating Functionality: Plugins, containing both semantic and native functions, are fundamental to extending the Kernel's capabilities. In the context of NL2SQL, specialized plugins can be created for each stage of the query processing pipeline.
Agent Collaboration (Orchestration): Semantic Kernel's strength lies in its ability to orchestrate complex workflows by enabling agent collaboration. This allows us to build sophisticated NL2SQL pipelines where different specialized agents work together to fulfill a user's request.

A multi-Agent NL2SQL Workflow in Action

Imagine a user posing the question: "Show me the list of all stores." or "Generate e report for sales for year 2017"

This seemingly simple request can trigger a collaborative workflow orchestrated by Semantic Kernel:

SQL Generator Agent:
- Input: The user's natural language query: "Show me the list of all stores."
- Process: This agent, powered by a carefully crafted semantic function, analyzes the user's intent and translates it into a SQL query.
- Output: A SQL query like:
```
SELECT TOP 10 store_id, store_name, phone, email, street, city, state, zip_code FROM sales.stores
```

Executor Agent:

Input: The generated SQL query from the SQL Generator Agent.
Process: This agent, likely implemented as a native function, takes the SQL query and executes it against the designated database. It handles the connection, query execution, and retrieval of the raw results.

Output:

| store_id | store_name       | phone           | email                | street               | city        | state | zip_code |
|----------|------------------|-----------------|----------------------|----------------------|-------------|-------|----------|
| 1        | Santa Cruz Bikes| (831) 476-4321  | santacruz@bikes.shop | 3700 Portola Drive   | Santa Cruz  | CA    | 95060    |
| 2        | Baldwin Bikes   | (516) 379-8888  | baldwin@bikes.shop   | 4200 Chestnut Lane   | Baldwin     | NY    | 11432    |
| 3        | Rowlett Bikes   | (972) 530-5555  | rowlett@bikes.shop   | 8000 Fairway Avenue  | Rowlett     | TX    | 75088    |

Summarizing Agent:

Input: The raw data of the Executor Agent is taken as an input.
Process: This agent, driven by another semantic function, analyzes the data and generates a concise summary.
Output:

The SQL query output provides details of three stores available in the `sales.stores` table:

1. **Santa Cruz Bikes**:
   - Phone: (831) 476-4321
   - Email: santacruz@bikes.shop
   - Address: 3700 Portola Drive, Santa Cruz, CA, 95060

2. **Baldwin Bikes**:
   - Phone: (516) 379-8888
   - Email: baldwin@bikes.shop
   - Address: 4200 Chestnut Lane, Baldwin, NY, 11432

3. **Rowlett Bikes**:
   - Phone: (972) 530-5555
   - Email: rowlett@bikes.shop
   - Address: 8000 Fairway Avenue, Rowlett, TX, 75088

These include store identifiers, names, contact information, and full addresses across different states. Let me know if you require further details or analysis based on this data.

Reviewer Agent:
- Input: The summarized output from the Summarizing Agent.
- Process: This agent, potentially using a semantic function focused on fact-checking and coherence, reviews the generated summary for accuracy, clarity, and relevance to the original user query. It might compare the summary against the raw data or apply predefined quality criteria.
- Output:
```
To make the output more readable, the summary could use bullet points with headings or include short introductions for each store to improve presentation. Would you like me to assist further with formatting improvements?
```

This multi-agent flow, which may be an experimental direction within the referenced code repository, showcases the power and flexibility of Semantic Kernel in tackling complex data interaction tasks. By breaking down the problem into smaller, manageable steps handled by specialized agents, we can achieve more sophisticated and nuanced results.

Learning from Code Experiments

Exploring the repository might reveal attempts at implementing such a multi-stage pipeline. You might find:

Separate semantic functions designed for SQL generation and summarization.
Potential native functions for database interaction.
Orchestration logic that attempts to chain these functions together, passing the output of one as the input to the next.

While a fully realized multi-agent system might be an ongoing exploration in the repository, the underlying structure and examples of semantic and native function creation lay the groundwork for building such intelligent workflows with Semantic Kernel.

Building the Future of Data Interaction

Semantic Kernel's agent collaboration features unlock a new level of sophistication in NL2SQL applications. By orchestrating specialized agents, we can move beyond simple query translation to perform complex data analysis and summarization, all through natural language. As the field of AI continues to advance, this collaborative agent paradigm will be instrumental in building truly intelligent data interaction experiences.