<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0"><channel><title><![CDATA[Evaluation of Natural Language to SQL Tools]]></title><description><![CDATA[Natural language to SQL]]></description><link>https://randominffo.hashnode.dev</link><generator>RSS for Node</generator><lastBuildDate>Wed, 18 Nov 2026 14:10:39 GMT</lastBuildDate><atom:link href="https://randominffo.hashnode.dev/rss.xml" rel="self" type="application/rss+xml"/><language><![CDATA[en]]></language><ttl>60</ttl><item><title><![CDATA[NL2SQL Tools with Both CLI and Python APIs: How to Choose]]></title><description><![CDATA[A lot of natural-language-to-SQL (NL2SQL) workflows follow a familiar arc. Someone types a question into a terminal, gets back SQL and a number, and pastes…]]></description><link>https://randominffo.hashnode.dev/nl2sql-tools-with-both-cli-and-python-apis-how-to-choose</link><guid isPermaLink="true">https://randominffo.hashnode.dev/nl2sql-tools-with-both-cli-and-python-apis-how-to-choose</guid><category><![CDATA[natural language processing]]></category><category><![CDATA[text to sql]]></category><category><![CDATA[data-engineering]]></category><dc:creator><![CDATA[Jalaj Giri]]></dc:creator><pubDate>Sat, 07 Nov 2026 11:21:26 GMT</pubDate><content:encoded><![CDATA[<p>A lot of natural-language-to-SQL (NL2SQL) workflows follow a familiar arc. Someone types a question into a terminal, gets back SQL and a number, and pastes the result into Slack. It's useful, so it becomes a cron job. Then someone wants it inside the internal dashboard, and the cron job turns into a function call in a Python service.</p>
<p>That last step is where things go quietly wrong. In the terminal you could see the generated SQL, whether it validated, and a readable error when the database was down. The Python service gets back a list of rows, and an empty list could mean "no orders this month", "the query was invalid" or "nothing ran at all". Nobody notices until a report shows zero revenue and no one can say why.</p>
<p>So when a tool advertises both a command-line interface (CLI) and a Python API, "does it have both?" is the wrong question. What you want to know is whether the same question carries the same information through both doors. This post works through that with NLQueries Core, Wren AI and PremSQL. The NLQueries details come from its pinned 0.4.1 source and a scripted run of that release with stubbed model responses. Wren and PremSQL details come from their docs and package metadata only. There are no timings, accuracy scores or a winner here, just a contract worth testing and the places where it already breaks.</p>
<h2>One question to carry through both interfaces</h2>
<p>It helps to follow a single, slightly awkward question. The synthetic fixture below has three tables: <code>customers</code>, <code>orders</code> and <code>order_items</code>. Customers 1 and 2 belong to tenant A and customer 3 to tenant B. Order 101 has two line items, so a careless join will double-count it. Order 106 is paid but has a NULL amount.</p>
<pre><code class="language-sql">-- Synthetic sample data (fixture F1), followed by the reference query
CREATE TABLE customers(id INTEGER PRIMARY KEY, tenant_id TEXT NOT NULL, region TEXT);
CREATE TABLE orders(id INTEGER PRIMARY KEY, customer_id INTEGER REFERENCES customers(id), order_date TEXT, amount_cents INTEGER, status TEXT);
CREATE TABLE order_items(id INTEGER PRIMARY KEY, order_id INTEGER REFERENCES orders(id), sku TEXT);
INSERT INTO customers VALUES(1,'A','East'),(2,'A','West'),(3,'B','North');
INSERT INTO orders VALUES
(101,1,'2026-10-01',10000,'PAID'),(102,1,'2026-10-02',5000,'CANCELLED'),
(103,2,'2026-10-31',20000,'PAID'),(104,3,'2026-10-02',70000,'PAID'),
(105,1,'2026-11-01',40000,'PAID'),(106,2,'2026-10-15',NULL,'PAID');
INSERT INTO order_items VALUES(1,101,'a'),(2,101,'b'),(3,103,'c');

-- Reference SQL
SELECT SUM(o.amount_cents) AS revenue_cents, COUNT(*) AS paid_order_count
FROM orders AS o JOIN customers AS c ON c.id = o.customer_id
WHERE c.tenant_id = 'A' AND o.status = 'PAID'
  AND o.order_date &gt;= '2026-10-01' AND o.order_date &lt; '2026-11-01';
</code></pre>
<p>The question to ask both interfaces is: <strong>"For tenant A, what were paid-order revenue in cents and paid-order count in October 2026?"</strong> Ask for both metrics explicitly. If you only ask about revenue, a perfectly reasonable one-column answer would fail a check that grades the count as well. The NULL-amount order adds nothing to revenue, but it still counts as an order.</p>
<p>Against this fixture on SQLite 3.45.3, the reference query returns <code>(30000, 3)</code>. The unique customer key prevents fan-out, the half-open date range keeps the November 1 order out, and <code>COUNT(*)</code> includes order 106. A tenant with no matching orders would get <code>(NULL, 0)</code>, which is a valid answer and not an error. That only confirms the fixture, not any NL2SQL product, and the tenant filter is arithmetic here, not an access control. Small as it is, the fixture holds the traps that matter when you compare interfaces: a NULL, a fan-out join and a date boundary.</p>
<h2>What parity should actually mean</h2>
<p>Two interfaces are at parity when a caller can tell the same things apart, not when they print the same number. The distinction that matters most is between three states that blur easily: SQL was <em>generated</em>, the SQL was <em>valid</em>, and the SQL was <em>executed</em>. The code that decides whether to retry, page someone or show a result has to tell an invalid query, an empty result and a run that never executed apart. If all three come back as an empty rows list, the interface has failed, however tidy the terminal output looks.</p>
<p>There's a fourth thing to keep separate, and that's what a preview is allowed to touch. In NLQueries Core 0.4.1 the execution policy controls whether the <em>generated</em> statement runs. <em>Literal grounding</em> has its own read-only permission (<a href="https://github.com/nlqueries/nlqueries/blob/2fbf276bf299e0b019c41cb62c5e6969d4c33ff9/nlqueries/execution.py">nlqueries.execution</a>). Grounding is the small set of lookups that check string literals in the SQL (say, <code>status = 'paid'</code>) against the values the column actually stores. It's on by default and runs whatever the execution policy is (<a href="https://github.com/nlqueries/nlqueries/blob/2fbf276bf299e0b019c41cb62c5e6969d4c33ff9/docs/configuration.md">configuration reference</a>). If your requirement is "a preview never touches the database", set <code>NLQ_LITERAL_GROUNDING=false</code> and confirm it in the database's own query log. Don't take the word "preview" at face value.</p>
<p>An automated caller also needs failures it can branch on without scraping prose, a clean session, and visible configuration: which knowledge base, connector, dialect, model and cache state a run used. The NLQueries CLI reference notes that exported context has to be refreshed explicitly (<a href="https://github.com/nlqueries/nlqueries/blob/2fbf276bf299e0b019c41cb62c5e6969d4c33ff9/docs/cli-reference.md">CLI Command Reference</a>). A terminal session that just re-exported can quietly disagree with a service still reading last week's export.</p>
<h2>NLQueries: the same question through two doors</h2>
<p>Start with the setup the CLI reference describes: load the fixture, register a connector, and export a knowledge base. The commands follow the sequence exercised against the pinned release. The <code>sqlite3</code> line is a placeholder for however you create the database, and <code>/absolute/path</code> must be a real absolute path throughout.</p>
<pre><code class="language-text">sqlite3 /absolute/path/sample.db &lt; fixture_f1.sql
nlqueries connect sqlite --database /absolute/path/sample.db --alias fixture
nlqueries export-kb fixture --no-include-samples
</code></pre>
<p><code>connect</code> prints the alias you chose and a canonical connector ID. The CLI accepts either. The Python runner expects the canonical one, so copy it exactly from that output. Core 0.4.1 keeps the path spelling you registered. An absolute path gives <code>sqlite:/absolute/path/sample.db</code>, but <code>./sample.db</code> stays <code>sqlite:./sample.db</code> and resolves against the process's working directory. Mix the two and the runner can't find the connector's knowledge base, so register, export and call with the same absolute path (<a href="https://github.com/nlqueries/nlqueries/blob/2fbf276bf299e0b019c41cb62c5e6969d4c33ff9/nlqueries/cli/main.py">CLI implementation</a>). <code>--no-include-samples</code> keeps column values out of the exported knowledge base and skips the sampling queries. Drop it if you want the prompt to see how values are spelled.</p>
<p>Now the question itself, once through the exploratory command and once the way a scheduled job would call it:</p>
<pre><code class="language-text">nlqueries ask fixture "For tenant A, what were paid-order revenue in cents and paid-order count in October 2026?"
nlqueries query fixture "For tenant A, what were paid-order revenue in cents and paid-order count in October 2026?" --no-execute --no-session --json --explain
</code></pre>
<p>The flags on the second line are doing real work, because <code>query</code> executes the generated SQL and carries session history by default. <code>--no-execute --no-session</code> turns it into a one-shot preview.</p>
<p>Here's the catch for parity. With <code>--json --explain</code>, the output includes <code>sql</code>, <code>sql_result</code>, a <code>session_id</code> and a provenance block. It doesn't include the generated statement's validity or the execution mode. This is the abridged shape from a scripted run, with the question strings and SQL elided:</p>
<pre><code class="language-json">{
  "question": "…",
  "resolved_question": "…",
  "agent_type": "sql",
  "answer": "",
  "sql": "SELECT SUM(o.amount_cents) AS revenue_cents, COUNT(*) AS paid_order_count …",
  "sql_result": null,
  "citations": [],
  "merged_answer": null,
  "latency_ms": 7,
  "session_id": null,
  "provenance": {
    "route": "sql",
    "cache": { "hit": false, "similarity": null, "tier": "" },
    "validator": [],
    "literals_grounded": [],
    "literal_repair": null
  }
}
</code></pre>
<p>The command exited 0, which is fine, but exit 0 isn't a validity signal, and a validation warning can land on stderr instead of in the JSON. A <code>null</code> <code>sql_result</code> is ambiguous on its own: the run could have been a preview, or the SQL could have been rejected. So record the flags, the JSON and stderr separately for every CLI run. In the same scripted run, <code>ask</code> printed a compact frame that did carry <code>is_valid</code> and <code>execution_mode</code>. <code>ask</code> is the exploratory single-agent path, though. It uses neither chat history nor the cache, so it can't stand in for <code>query</code> in a job.</p>
<p>The Python side exposes the fields explicitly. The runner module provides <code>run_query</code>, <code>run_query_sync</code> and an <code>AgentQueryResult</code> that carries <code>sql</code>, <code>sql_is_valid</code>, <code>execution_mode</code> and <code>sql_result</code> (<a href="https://github.com/nlqueries/nlqueries/blob/2fbf276bf299e0b019c41cb62c5e6969d4c33ff9/nlqueries/orchestrator/sync_runner.py">nlqueries.orchestrator.sync_runner</a>). The function below is a small custom host adapter, not part of NLQueries. It assumes <code>nlqueries-core</code> 0.4.1 is installed with the dependencies in its package metadata (<a href="https://github.com/nlqueries/nlqueries/blob/2fbf276bf299e0b019c41cb62c5e6969d4c33ff9/pyproject.toml">pyproject.toml</a>), and an exported knowledge base for the connector.</p>
<pre><code class="language-python"># Custom adapter (not part of NLQueries), written for Core 0.4.1.
# Exercised against the pinned release with a scripted model; not run against a live LLM provider.
from nlqueries.execution import ExecutionPolicy
from nlqueries.orchestrator.sync_runner import run_query

async def preview(question: str, configured_agent_id: str):
    return await run_query(
        question=question,
        agent_id=configured_agent_id,
        dialect="sqlite",
        execution=ExecutionPolicy.generate_only(),
        use_cache=False,
        explain=True,
    )
</code></pre>
<pre><code class="language-python"># Calling it from a script; the agent ID is the canonical one printed by `connect`.
import asyncio

QUESTION = ("For tenant A, what were paid-order revenue in cents "
            "and paid-order count in October 2026?")
result = asyncio.run(preview(QUESTION, "sqlite:/absolute/path/sample.db"))
print(result.sql_is_valid, result.execution_mode, result.sql)
</code></pre>
<p>The scripted run's outcomes show why explicit fields matter. In every case below, the model's response was a test double. These results describe how the interface behaves, not answer quality.</p>
<table>
<thead>
<tr>
<th>Case</th>
<th><code>sql_is_valid</code></th>
<th><code>execution_mode</code></th>
<th><code>sql_result</code></th>
</tr>
</thead>
<tbody><tr>
<td>Preview through the adapter</td>
<td><code>True</code></td>
<td><code>generate_only</code></td>
<td><code>None</code></td>
</tr>
<tr>
<td>Separately authorized run of the same SQL</td>
<td>—</td>
<td>read-only execution</td>
<td>rows <code>[[30000, 3]]</code></td>
</tr>
<tr>
<td>Valid SQL, no matching rows</td>
<td><code>True</code></td>
<td><code>execute_read_only</code></td>
<td><code>rows=[]</code>, <code>error=None</code></td>
</tr>
<tr>
<td>SQL naming a table that doesn't exist</td>
<td><code>False</code></td>
<td><code>execute_read_only</code></td>
<td><code>None</code></td>
</tr>
<tr>
<td>Valid SQL, database error</td>
<td><code>True</code></td>
<td><code>execute_read_only</code></td>
<td><code>rows=[]</code>, <code>error='integer overflow'</code></td>
</tr>
</tbody></table>
<p>Look at the last two rows. A database error also returns an empty rows list, and the only thing telling it apart from "no orders" is the result's <code>error</code> field. Read validity, mode and <code>sql_result.error</code> before you trust <code>rows</code>. When you do want rows, ask for them in a separately authorized path with <code>ExecutionPolicy.execute_read_only()</code>.</p>
<h2>Where the two doors quietly differ</h2>
<p>Even when they're given the same question, NLQueries' two surfaces start from different defaults. The Python runner defaults to generation only. CLI <code>query</code> defaults to execution with session history. <code>--no-session</code> stops conversation context from carrying over, but it doesn't turn off the semantic cache, while the adapter above passes <code>use_cache=False</code>. When Qdrant is reachable, the cache is on. A hit replays the stored answer text and re-executes the stored SQL only if the request permits execution, so a <code>--no-execute</code> hit returns no execution result (<a href="https://github.com/nlqueries/nlqueries/blob/2fbf276bf299e0b019c41cb62c5e6969d4c33ff9/docs/cli-reference.md">CLI Command Reference</a>; <a href="https://github.com/nlqueries/nlqueries/blob/2fbf276bf299e0b019c41cb62c5e6969d4c33ff9/nlqueries/execution.py">execution.py</a>; <a href="https://github.com/nlqueries/nlqueries/blob/2fbf276bf299e0b019c41cb62c5e6969d4c33ff9/nlqueries/orchestrator/multi_agent_orchestrator.py">multi_agent_orchestrator.py</a>). For a cold parity check, give both interfaces an empty, isolated cache and keep <code>provenance.cache.hit</code> with each result. History works differently too. The CLI stores it per agent. A Python follow-up is resolved from the history the caller passes in, and a <code>session_id</code> alone doesn't load anything.</p>
<p>Then there's the difference between previewing and approving. Calling the runner again starts a new request. That request may generate fresh SQL, or it may reuse a cached statement. Neither binds the statement your user looked at. In a scripted test with an injected cache entry, the replayed narrative said 30000 cents while the freshly executed rows said 31000. If your product shows someone SQL and they click "approve", authorize that exact stored statement and its parameters. Don't send the natural-language question again and hope the same SQL comes back. NLQueries doesn't build that binding for you. It's your code.</p>
<p>The last trap is async. <code>run_query_sync</code> wraps <code>asyncio.run</code>, which is fine in a script or cron job. Inside a running event loop, such as a FastAPI handler or a notebook, it fails. In the scripted test it raised <code>RuntimeError</code> ("asyncio.run() cannot be called from a running event loop"). There, <code>await run_query</code> directly.</p>
<p>Execution as a parameter rather than a side effect is the right shape, but it means that in 0.4.1 the Python runner is the surface to build an automation contract on.</p>
<h2>Wren AI and PremSQL: different shapes of "both"</h2>
<p>Wren AI has a real CLI, but its commands divide the work differently from NLQueries (<a href="https://github.com/Canner/WrenAI/blob/548eee32Epo1K92Xzo6Hayq1Fmkj21x4fUk7JZT7/docs/core/reference/cli.md">Wren CLI reference</a>). <code>wren ask QUESTION --guided</code> prints instructions for an external agent. <code>ask</code> needs either <code>--guided</code> or <code>--direct</code>, and it doesn't execute SQL. <code>wren dry-plan</code> plans SQL against the modeled project, <code>wren query</code> runs it, and <code>wren serve mcp</code> exposes a prepared project to an MCP client. On the Python side, the framework SDKs consume a project you've already prepared through the CLI, which the docs describe as an author-time and run-time split (<a href="https://docs.getwren.ai/oss/sdk/overview">SDKs &amp; Integrations</a>). A LangChain toolkit is one integration route (<a href="https://docs.getwren.ai/oss/sdk/langchain">wren-langchain</a>).</p>
<p>That changes what a fair test looks like. The natural-language generation is often done by an external agent you bring, so a parity test has to cover the whole agent-plus-tools workflow, counting that generation step. If you want a semantic layer authored up front, that split may be exactly right. The SDK pages are live docs, and installed package versions weren't checked.</p>
<p>PremSQL comes at the problem from the Python side. Its README shows generators and executors, including local generation with Hugging Face models and SQLite execution, plus a cloud-backed quickstart and a playground (<a href="https://github.com/premAI-io/premsql/blob/7041239e5ce10f87e99e8df1bc669a2b778f9cb4/README.md">PremSQL README</a>). Version 0.2.10 does ship a native CLI (<a href="https://github.com/premAI-io/premsql/blob/7041239e5ce10f87e99e8df1bc669a2b778f9cb4/pyproject.toml">pyproject.toml</a>, <a href="https://github.com/premAI-io/premsql/blob/7041239e5ce10f87e99e8df1bc669a2b778f9cb4/premsql/cli.py">premsql/cli.py</a>). Its commands are <code>premsql launch api</code>, <code>premsql launch all</code> and <code>premsql stop</code>, which manage services and don't answer a question. For terminal question-to-result parity, you'd write an application adapter around the generator and executor. That adapter is your code to maintain, and it shouldn't count as the tool's interface.</p>
<table>
<thead>
<tr>
<th>Candidate</th>
<th>Native CLI</th>
<th>Question-to-SQL from the terminal</th>
<th>Python path</th>
<th>Where parity stands</th>
</tr>
</thead>
<tbody><tr>
<td>NLQueries Core 0.4.1</td>
<td>Yes: <code>connect</code>, <code>export-kb</code>, <code>ask</code>, <code>query</code>, <code>eval</code> and others</td>
<td>Yes (<code>ask</code>, <code>query</code>)</td>
<td><code>run_query</code>, <code>run_query_sync</code></td>
<td>Both paths exist; <code>query --json</code> omits validity and execution mode</td>
</tr>
<tr>
<td>Wren AI (current docs)</td>
<td>Yes: <code>ask</code>, <code>dry-plan</code>, <code>query</code>, <code>serve mcp</code> and others</td>
<td>Via an external agent (<code>ask</code> prints a prompt)</td>
<td>Framework SDKs over a prepared project</td>
<td>Compare whole agent-plus-tools workflows</td>
</tr>
<tr>
<td>PremSQL 0.2.10</td>
<td>Yes: <code>launch api</code>, <code>launch all</code>, <code>stop</code></td>
<td>No (service management only)</td>
<td>Generators and executors</td>
<td>Needs your own adapter for terminal parity</td>
</tr>
</tbody></table>
<p>The table shows what exists, not how well any of it works.</p>
<h2>Break it on purpose</h2>
<p>A happy-path answer is the weakest evidence you can collect. The tests worth writing are the ones where your automation has to decide what happens next. And keep two kinds of test apart. Interface tests can use a scripted model, because you're checking fields and failure behavior. Answer-quality tests need a real, authorized provider and the full question.</p>
<p>Start with missing pieces. In a disposable environment, run each interface with the exported knowledge base removed, then stale, then with a bad database credential. Capture stderr, the exception or JSON body, and the exit code, and check that no secret leaks into anything you keep. Your code should tell a retryable failure (a dropped connection) from a permanent one (missing context) without parsing human-readable messages.</p>
<p>Then go after the edges. Set a deliberately short database timeout. Run SQL that's valid but matches zero rows, and SQL that names a table that doesn't exist. Ask for a table the caller's role can't see. Ask a paraphrase that should hit the cache. Phrase the question so the model is tempted to join <code>order_items</code> and inflate order 101. For each run, record separately whether the SQL was valid, whether policy accepted it, whether the answer was correct, how well the tool refused, and whether execution succeeded. A statement that parses and passes schema checks hasn't proven the business answer or the authorization. When you compare results, treat them as multisets unless ordering was requested, and keep integer cents and NULL behavior intact so order 106 doesn't disappear from the count.</p>
<h2>How to make the call</h2>
<p>Run the evaluation in three passes. None of them has been run end to end with a live model.</p>
<ol>
<li><strong>Parity matrix.</strong> Send the full fixture question through CLI JSON and through Python with the same knowledge base, dialect and model, and an empty cache. Record the SQL, rows, validity, execution mode, error behavior, session and permission settings, and cache provenance. Expect equivalent result sets, not byte-identical SQL. A surface fails if a caller can't tell invalid, empty and not-executed apart from its output alone.</li>
<li><strong>Async and preview harness.</strong> Call <code>run_query_sync</code> outside an event loop and <code>await run_query</code> inside one. Try generate-only with grounding on and off, then read-only execution, with the database's query log running. It fails if a preview runs the generated SQL.</li>
<li><strong>Failure contract.</strong> Run the missing knowledge base, bad credential, timeout, denied role, zero-row, invalid-SQL and cache-hit cases on both interfaces.</li>
</ol>
<p>To weigh the results, start from something like this and adjust it. These weights are an editorial proposal, not measurements:</p>
<table>
<thead>
<tr>
<th>Criterion</th>
<th>Proposed weight</th>
</tr>
</thead>
<tbody><tr>
<td>Task parity</td>
<td>30%</td>
</tr>
<tr>
<td>Structured results and errors</td>
<td>25%</td>
</tr>
<tr>
<td>Automation and async behavior</td>
<td>20%</td>
</tr>
<tr>
<td>Configuration portability</td>
<td>15%</td>
</tr>
<tr>
<td>Compatibility and maintenance</td>
<td>10%</td>
</tr>
</tbody></table>
<p>Score each criterion on a 0–4 scale you define before testing. A zero means an observed failure. A criterion nobody has measured stays "unknown" and gets no number, and no total gets published while a material cell is blank. Hold off on claims about setup time or maintenance burden until there are timed runs, too. A five-line import example tells you nothing about how long an installation takes.</p>
<p>On what's documented and observable today, NLQueries gives you a real question-to-SQL path through both doors. Its Python runner is the one that keeps validity, execution mode and errors explicit. Wren is a strong fit if you want a modeled project authored up front and an external agent doing the generation. PremSQL is the Python-first option, with a CLI for running services rather than asking questions. Whichever way you lean, check licensing separately. NLQueries Core 0.4.1 is source available under the Business Source License 1.1, and its Additional Use Grant restricts offering the functionality to third parties as a hosted or managed service (<a href="https://github.com/nlqueries/nlqueries/blob/2fbf276bf299e0b019c41cb62c5e6969d4c33ff9/LICENSE">Core LICENSE</a>). Being able to read the source doesn't settle your deployment rights.</p>
<p>Here's a concrete next step. Load the fixture above, pin your versions, and run the parity pass with the full question on both interfaces, with an empty cache. Keep the raw JSON, stderr and result objects, with secrets redacted. If your code can tell "invalid", "empty", "failed" and "not executed" apart on both surfaces without guessing, choosing a tool stops being a gamble. It becomes a question of integration fit.</p>
<h2>References</h2>
<ul>
<li><a href="https://github.com/nlqueries/nlqueries/blob/2fbf276bf299e0b019c41cb62c5e6969d4c33ff9/docs/cli-reference.md">CLI Command Reference — NLQueries Core 0.4.1</a></li>
<li><a href="https://github.com/nlqueries/nlqueries/blob/2fbf276bf299e0b019c41cb62c5e6969d4c33ff9/docs/configuration.md">Configuration reference — NLQueries Core 0.4.1</a></li>
<li><a href="https://github.com/nlqueries/nlqueries/blob/2fbf276bf299e0b019c41cb62c5e6969d4c33ff9/nlqueries/orchestrator/sync_runner.py">nlqueries.orchestrator.sync_runner</a></li>
<li><a href="https://github.com/nlqueries/nlqueries/blob/2fbf276bf299e0b019c41cb62c5e6969d4c33ff9/nlqueries/execution.py">nlqueries.execution</a></li>
<li><a href="https://github.com/nlqueries/nlqueries/blob/2fbf276bf299e0b019c41cb62c5e6969d4c33ff9/nlqueries/cli/main.py">nlqueries/cli/main.py — NLQueries Core 0.4.1</a></li>
<li><a href="https://github.com/nlqueries/nlqueries/blob/2fbf276bf299e0b019c41cb62c5e6969d4c33ff9/nlqueries/orchestrator/multi_agent_orchestrator.py">nlqueries/orchestrator/multi_agent_orchestrator.py — NLQueries Core 0.4.1</a></li>
<li><a href="https://github.com/nlqueries/nlqueries/blob/2fbf276bf299e0b019c41cb62c5e6969d4c33ff9/pyproject.toml">pyproject.toml — nlqueries-core</a></li>
<li><a href="https://github.com/nlqueries/nlqueries/blob/2fbf276bf299e0b019c41cb62c5e6969d4c33ff9/LICENSE">LICENSE — NLQueries Core 0.4.1</a></li>
<li><a href="https://github.com/Canner/WrenAI/blob/548eee32Epo1K92Xzo6Hayq1Fmkj21x4fUk7JZT7/docs/core/reference/cli.md">CLI Reference — Wren AI</a></li>
<li><a href="https://docs.getwren.ai/oss/sdk/overview">SDKs &amp; Integrations | Wren AI Docs</a></li>
<li><a href="https://docs.getwren.ai/oss/sdk/langchain">wren-langchain | Wren AI Docs</a></li>
<li><a href="https://github.com/premAI-io/premsql/blob/7041239e5ce10f87e99e8df1bc669a2b778f9cb4/README.md">PremSQL README (commit 7041239)</a></li>
<li><a href="https://github.com/premAI-io/premsql/blob/7041239e5ce10f87e99e8df1bc669a2b778f9cb4/pyproject.toml">pyproject.toml — PremSQL</a></li>
<li><a href="https://github.com/premAI-io/premsql/blob/7041239e5ce10f87e99e8df1bc669a2b778f9cb4/premsql/cli.py">premsql/cli.py — PremSQL</a></li>
</ul>
<hr />
]]></content:encoded></item></channel></rss>