Queryweaver

REST API · MCP · Graph-powered

QueryWeaver is an open-source Text2SQL tool that converts plain-English questions into SQL using graph-powered schema understanding. It helps you ask databases natural-language questions and returns SQL and results.

Connect and ask questions:

Get Started

Docker

💡 Recommended for evaluation purposes (Local Python or Node are not required)

docker run -p 5000:5000 -it falkordb/queryweaver

Launch: http://localhost:5000

Use an .env file (Recommended)

Create a local .env by copying .env.example and passing it to Docker. This is the simplest way to provide all required configuration:

cp .env.example .env
# edit .env to set your values, then:
docker run -p 5000:5000 --env-file .env falkordb/queryweaver

Alternative: Pass individual environment variables

If you prefer to pass variables on the command line, use -e flags (less convenient for many variables):

docker run -p 5000:5000 -it \
  -e APP_ENV=development \
  -e FASTAPI_SECRET_KEY=your_super_secret_key_here \
  -e GOOGLE_CLIENT_ID=your_google_client_id \
  -e GOOGLE_CLIENT_SECRET=your_google_client_secret \
  -e GITHUB_CLIENT_ID=your_github_client_id \
  -e GITHUB_CLIENT_SECRET=your_github_client_secret \
  -e AZURE_API_KEY=your_azure_api_key \
  falkordb/queryweaver

APP_ENV=development is what makes the login work on the plain-HTTP http://localhost:5000 this command serves. Drop it (or set anything else) when you put QueryWeaver behind HTTPS, so the session cookie is marked Secure. See Application environment.

Note: QueryWeaver supports multiple AI providers. You can use OPENAI_API_KEY, GEMINI_API_KEY, ANTHROPIC_API_KEY, or AZURE_API_KEY. See the AI/LLM configuration section for details.

For a full list of configuration options, consult .env.example.

Memory TTL (optional)

QueryWeaver stores per-user conversation memory in FalkorDB. By default these graphs persist indefinitely. Set MEMORY_TTL_SECONDS to apply a Redis TTL (in seconds) so idle memory graphs are automatically cleaned up.

# Expire memory graphs after 1 week of inactivity
MEMORY_TTL_SECONDS=604800

The TTL is refreshed on every user interaction, so active users keep their memory.

MCP server: host or connect (optional)

QueryWeaver includes optional support for the Model Context Protocol (MCP). You can either have QueryWeaver expose an MCP-compatible HTTP surface (so other services can call QueryWeaver as an MCP server), or configure QueryWeaver to call an external MCP server for model/context services.

What QueryWeaver provides

• The app registers MCP operations focused on Text2SQL flows:
• list_databases
• connect_database
• database_schema
• query_database

• To disable the built-in MCP endpoints set DISABLE_MCP=true in your .env or environment (default: MCP enabled).
• Configuration

• DISABLE_MCP — disable QueryWeaver's built-in MCP HTTP surface. Set to true to disable. Default: false (MCP enabled).

Examples

Disable the built-in MCP when running with Docker:

docker run -p 5000:5000 -it --env DISABLE_MCP=true falkordb/queryweaver

Calling the built-in MCP endpoints (example)

• The MCP surface is exposed as HTTP endpoints.

Server Configuration

Below is a minimal example mcp.json client configuration that targets a local QueryWeaver instance exposing the MCP HTTP surface at /mcp.

{
   "servers": {
      "queryweaver": {
         "type": "http",
         "url": "http://127.0.0.1:5000/mcp",
         "headers": {
            "Authorization": "Bearer your_token_here"
         }
      }
   },
   "inputs": []
}

REST API

API Documentation

Swagger UI: https://app.queryweaver.ai/docs

OpenAPI JSON: https://app.queryweaver.ai/openapi.json

Overview

QueryWeaver exposes a small REST API for managing graphs (database schemas) and running Text2SQL queries. All endpoints that modify or access user-scoped data require authentication. In the browser the app uses a signed session cookie established by OAuth or email/password; for CLI and scripts you can use an API token (see tokens routes or the web UI to create one).

Core endpoints

• GET /graphs — list available graphs for the authenticated user
• GET /graphs/{graph_id}/data — return nodes/links (tables, columns, foreign keys) for the graph
• POST /graphs — upload or create a graph (JSON payload or file upload)
• POST /graphs/{graph_id} — run a Text2SQL chat query against the named graph (streaming response)

Authentication

• Add an Authorization header: Authorization: Bearer <API_TOKEN>

#### Three separate credentials

QueryWeaver keeps its three kinds of "login" independent of one another, so a failure in one never looks like a failure in another:

Because the browser login is a signed cookie, staying logged in costs no database round trip and survives a FalkorDB outage in an already-running process — you keep your session and only the operations that genuinely need the graph fail. Requests that supply an API token explicitly are always checked against the database and are answered with 503 (not 401) when it cannot be reached, so clients retry instead of re-authenticating.

Note the scope: this is about staying logged in, not about booting. QueryWeaver still connects to FalkorDB at startup and will not start without it, so a restart during an outage is not covered.

A browser login lasts 24 hours by default; set BROWSER_SESSION_TTL_HOURS to change that. Logging out clears the session cookie. No API token is issued to the browser, so there is none to revoke — tokens are created explicitly from the tokens API and revoked there. (A legacy api_token cookie left over from an older release is cleared and revoked on logout too.)

#### Email signup is verified before the account exists

Signing up with an email address and password does not create an account. The submitted details are parked, a six-digit confirmation code is mailed to the address, and the account — and the session — come into being only when that code is typed back into the signup form. So an address the registrant does not control never becomes an account at all, and there is no half-real user for the rest of the system to reason about.

A code rather than an emailed link, because the code has to come back to the session that submitted the form. A link can be opened by anyone who receives it: a stranger could submit your address with a password of their choosing, and your single click would create an account they knew the password to. Nobody can be signed up by someone else here, because the person who fills in the form is the only one who ever holds both halves.

The code is single-use, expires after 15 minutes and tolerates only a handful of wrong guesses before the pending signup is discarded — a short code is only safe while the number of attempts is small. It is also only redeemable in the browser that submitted the form: each submission mints a ticket that stays in that browser's session, and a code presented without its ticket is refused. Entering it signs the browser in directly: the password was chosen minutes earlier, and asking for it again would prove nothing. A code can be re-sent from the same screen, subject to a per-address rate limit; the send budget is per pending signup, so it starts over once the pending signup expires and an address can always be signed up again later. Typing a code that has expired is not one of the wrong guesses and does not discard anything — the pending signup is left where it is so the same screen can send a fresh code.

In development, a message with no mail server configured is written to the application log instead of being sent, so the flow can be completed by copying the code out of the log. This needs APP_ENV=development — anywhere else an unconfigured process refuses the send rather than logging the code and reporting success. Set MAIL_SERVER (plus MAIL_PORT, MAIL_USERNAME,