Update CONTRIBUTORS.md and README.md to include Python DSL support

This commit enhances the documentation by adding support for the Python DSL in both the CONTRIBUTORS.md and README.md files. The changes reflect the addition of Python as a query authoring option alongside Rust, TypeScript, and Go, and provide examples for using the Python client to build and send dynamic requests. This update improves clarity and accessibility for users utilizing the Python SDK.

Author: xav-db

CONTRIBUTORS.md

@@ -190,7 +190,7 @@ The v3 CLI is a runtime orchestrator — there is no `helix compile`/`helix chec
 
 1. Scaffold a project with `helix init` (writes `helix.toml` and a `.helix/` workspace).
 2. Start a local instance with `helix start` — a Docker/Podman container running the `enterprise-dev` image (in-memory by default, on-disk with `--disk`).
-3. Author queries with the Rust or TypeScript DSL; they serialize to JSON "dynamic queries".
+3. Author queries with the Rust, TypeScript, Go, or Python DSL; they serialize to JSON "dynamic queries".
 4. Send queries to a running instance via `POST /v1/query` (`helix query`); validation happens server-side.
 5. For production, deploy an Enterprise Cloud instance with `helix push`, managing auth/metadata via `helix auth`, `helix sync`, and the `workspace`/`project`/`cluster` commands.
 
@@ -201,6 +201,7 @@ Client libraries that build HelixDB queries and send them to a running instance.
 - `rust/` - Rust DSL builder (crate `helix-db`), with the `helix-dsl-macros` procedural-macro crate
 - `typescript/` - TypeScript DSL (`@helix-db/helix-db`)
 - `go/` - Go client and DSL
+- `python/` - Python client and DSL (`helix-db`, imported as `helixdb`)
 - `tests/` - Cross-SDK parity tests and metadata registration tests
 
 #### `/metrics/` - Metrics
@@ -212,7 +213,7 @@ Logos and images used in the README and docs.
 ## Key Concepts
 
 ### Query Language
-Queries are authored with the Rust or TypeScript DSL (in `sdks/`) and serialized to JSON "dynamic queries" sent to a running instance. The legacy HelixQL `.hx` form below is still supported for reference and translation:
+Queries are authored with the Rust, TypeScript, Go, or Python DSL (in `sdks/`) and serialized to JSON "dynamic queries" sent to a running instance. The legacy HelixQL `.hx` form below is still supported for reference and translation:
 ```
 QUERY addUser(name: String, age: I64) =>
    user <- AddN<User({name: name, age: age})
@@ -232,7 +233,7 @@ QUERY addUser(name: String, age: I64) =>
 
 ## Architecture Flow
 
-1. **Definition**: Author queries with the Rust or TypeScript DSL
+1. **Definition**: Author queries with a Rust, TypeScript, Go, or Python DSL
 2. **Serialization**: The DSL produces a JSON dynamic-query AST (`POST /v1/query` body)
 3. **Execution**: Send to a running instance with `helix query`; the gateway validates and runs it server-side
 4. **Storage**: LMDB handles persistence with ACID guarantees

README.md

@@ -78,7 +78,7 @@ If you'd rather wire things up yourself:
 
 ## Writing queries with the SDKs
 
-Queries are authored with the Rust or TypeScript DSL and sent straight to a running instance as dynamic requests against `POST /v1/query` — no build or deploy step. Both SDKs produce the same JSON AST. The examples below talk to a local instance on `http://localhost:6969` (the default `helix start dev` port). See the [Querying Guide](https://docs.helix-db.com/database/querying-guide/overview) for the full builder catalog and the dynamic-query wire format.
+Queries are authored with the Rust, TypeScript, Go, or Python DSL and sent straight to a running instance as dynamic requests against `POST /v1/query` — no build or deploy step. The SDKs produce the same JSON AST. The examples below talk to a local instance on `http://localhost:6969` (the default `helix start dev` port). See the [Querying Guide](https://docs.helix-db.com/database/querying-guide/overview) for the full builder catalog and the dynamic-query wire format.
 
 ### Rust
 
@@ -197,6 +197,52 @@ const user = await fetch(HELIX_URL, {
 console.log("user:", user);
 ```
 
+### Python
+
+Install the package from this repository:
+
+```bash
+pip install -e sdks/python
+```
+
+Build dynamic requests with snake_case builders, then send them with the client:
+
+```python
+from helixdb import Client, Predicate, g, param, define_params, read_batch, write_batch
+
+add_user_params = define_params({"name": param.string()})
+add_user = (
+    write_batch()
+    .var_as("user", g().add_n("User", {"name": add_user_params.name}))
+    .returning(["user"])
+)
+
+get_user_params = define_params({"name": param.string()})
+get_user = (
+    read_batch()
+    .var_as(
+        "user",
+        g()
+        .n_with_label("User")
+        .where(Predicate.eq("name", get_user_params.name))
+        .value_map(["name"]),
+    )
+    .returning(["user"])
+)
+
+client = Client("http://localhost:6969")
+
+new_user = client.query().dynamic(
+    add_user.to_dynamic_request(add_user_params, {"name": "John Doe"})
+).send()
+print("new user:", new_user)
+
+user = client.query().dynamic(
+    get_user.to_dynamic_request(get_user_params, {"name": "John Doe"})
+).send()
+print("user:", user)
+```
+
 ## HelixDB Cloud
 
 HelixDB Cloud is an object-storage-backed deployment with integrated vector and full-text search, full ACID transactions, a single writer with auto-scaling reader nodes, and high availability (3+ gateways and DB nodes). Cloud clusters use a separate deploy path from local instances:
@@ -224,4 +270,4 @@ HelixDB is available as a distributed, high-availability, managed service. If yo
 
 ---
 
-Just Use Helix.
+Just Use Helix.

sdks/python/README.md

@@ -0,0 +1,74 @@
+# HelixDB Python SDK
+
+The Python SDK pairs an idiomatic query-builder DSL with a small dependency-free
+HTTP client for sending dynamic HelixDB queries to `POST /v1/query`.
+
+```python
+from helixdb import Client, Predicate, g, read_batch
+
+query = (
+    read_batch()
+    .var_as(
+        "users",
+        g()
+        .n_with_label("User")
+        .where(Predicate.eq("status", "active"))
+        .limit(25)
+        .value_map(["$id", "name", "status"]),
+    )
+    .returning(["users"])
+)
+
+request = query.to_dynamic_request()
+result = Client("http://localhost:6969").query().dynamic(request).send()
+```
+
+The DSL emits the same dynamic-query JSON AST as the Rust, TypeScript, and Go
+SDKs. Python methods use `snake_case`; compatibility aliases such as
+`nWithLabel` and `valueMap` are also available for users translating TypeScript
+examples directly.
+
+## Dynamic Parameters
+
+```python
+from helixdb import Predicate, define_params, g, param, read_batch
+
+params = define_params({
+    "tenant_id": param.string(),
+    "limit": param.i64(),
+})
+
+query = (
+    read_batch()
+    .var_as(
+        "users",
+        g()
+        .n_with_label("User")
+        .where(Predicate.eq("tenantId", params.tenant_id))
+        .limit(params.limit)
+        .value_map(["$id", "name", "tenantId"]),
+    )
+    .returning(["users"])
+)
+
+body = query.to_dynamic_json(
+    params,
+    {"tenant_id": "acme", "limit": 10},
+    query_name="find_users",
+)
+```
+
+## Stored Queries
+
+```python
+from helixdb import Client
+
+client = Client("https://cluster.helix-db.com", api_key="hx_secret")
+response = client.query().body({"tenant_id": "acme"}).stored("find_users").send()
+```
+
+Run the SDK tests from the repository root:
+
+```sh
+PYTHONPATH=sdks/python/src python -m unittest discover sdks/python/tests
+```

sdks/python/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "helix-db"
+version = "0.1.0"
+description = "Python SDK for HelixDB dynamic query DSL and client"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "HelixDB" }]
+keywords = ["helixdb", "graph", "vector", "database", "dsl"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+]
+
+[project.urls]
+Homepage = "https://github.com/HelixDB/helix-db"
+Repository = "https://github.com/HelixDB/helix-db"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+helixdb = ["py.typed"]

sdks/python/src/helix_db/__init__.py

@@ -0,0 +1,3 @@
+"""Compatibility import path for the HelixDB Python SDK."""
+
+from helixdb import *  # noqa: F401,F403

sdks/python/src/helixdb/__init__.py

@@ -0,0 +1,13 @@
+"""HelixDB Python SDK."""
+
+from .client import Client, HelixDBClient, HelixError, QueryBuilder, QueryRequest
+from .dsl import *
+
+__all__ = [
+    "Client",
+    "HelixDBClient",
+    "HelixError",
+    "QueryBuilder",
+    "QueryRequest",
+    *[name for name in globals() if not name.startswith("_")],
+]