gragdb 0.1.0__tar.gz

gragdb-0.1.0/.gitignore

@@ -0,0 +1,13 @@
+.venv/
+.tools/
+__pycache__/
+*.pyc
+*.lbdb
+*.wal
+dist/
+build/
+*.egg-info/
+node_modules/
+ui/dist/
+src/grag/api/static/
+.pytest_cache/

gragdb-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Adam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gragdb-0.1.0/PKG-INFO

@@ -0,0 +1,210 @@
+Metadata-Version: 2.4
+Name: gragdb
+Version: 0.1.0
+Summary: LLM-first graph knowledgebase: embedded Cypher engine, MCP tool contract, GraphRAG retrieval
+License: MIT
+License-File: LICENSE
+Requires-Python: <3.15,>=3.10
+Requires-Dist: fastapi>=0.110
+Requires-Dist: ladybug>=0.19
+Requires-Dist: mcp>=2.0
+Requires-Dist: numpy>=1.26
+Requires-Dist: pydantic>=2.6
+Requires-Dist: uvicorn>=0.29
+Provides-Extra: dev
+Requires-Dist: httpx>=0.27; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: pyyaml>=6.0; extra == 'dev'
+Provides-Extra: embed-local
+Requires-Dist: fastembed>=0.4; extra == 'embed-local'
+Provides-Extra: embed-remote
+Requires-Dist: httpx>=0.27; extra == 'embed-remote'
+Description-Content-Type: text/markdown
+
+# grag
+
+**LLM-first graph knowledgebase.** One embedded Cypher engine ([LadybugDB](https://ladybugdb.com), the Kuzu successor), one file per database, zero daemons — wrapped in the tool contract LLMs actually need: schema introspection that anchors text-to-Cypher, idempotent upserts with provenance, hybrid FTS/vector search, and token-budgeted subgraph context for grounded, low-hallucination answers.
+
+*(**G**(raph)**RAG** — retrieval-augmented generation grounded in a graph.)*
+
+Not an enterprise platform. `pip install`, point an MCP client at it, done.
+
+## Why
+
+LLM answers hallucinate when retrieval returns isolated chunks. grag stores knowledge as a **graph** — entities, documents, and their relationships — so retrieval returns a connected, cited subgraph an LLM can reason over. The LLM can also *build* the graph: `define_schema` + `upsert_nodes/edges` are first-class tools, so "turn these docs into a knowledge graph" is a normal conversation, not a pipeline project.
+
+## Install
+
+**From PyPI** (ships the web UI):
+
+```bash
+pip install gragdb
+```
+
+Python 3.10–3.14; **3.13 recommended** (faster interpreter for the Python-side
+packing/serialization paths, and 3.10 reaches end-of-life in October 2026).
+
+**From source** (for development). Build the UI **first** — `pip install` needs the
+built bundle at `src/grag/api/static` (the wheel's force-include; see `pyproject.toml`):
+
+```bash
+cd ui && npm ci && npm run build && cd ..   # builds the UI into src/grag/api/static/
+pip install -e .            # core: engine, REST, MCP, FTS — no torch, no GPU stack
+pip install -e ".[dev]"     # tests
+pip install -e ".[embed-local]"   # optional: local embeddings (fastembed/ONNX, still no torch)
+pip install -e ".[embed-remote]"  # optional: OpenAI-compatible remote embeddings
+```
+
+Without an embedder, everything works FTS-only (BM25 is native to the engine).
+
+**Enabling semantic search:** install `embed-local`, then set `GRAG_EMBED_PROVIDER=fastembed`
+when serving. This uses ONNX Runtime — **no PyTorch** — so grag stays light (~50-100MB,
+model downloads once then works offline). Nodes are (re)embedded lazily on the next
+search whenever their embedding is NULL. First query downloads the model + embeds all
+nodes (seconds); steady state is ~300ms/query on CPU.
+
+```bash
+pip install -e ".[embed-local]"
+GRAG_EMBED_PROVIDER=fastembed grag --db knowledge.lbdb serve
+# optional: GRAG_EMBED_MODEL=BAAI/bge-base-en-v1.5 GRAG_EMBED_DIM=768
+```
+
+## Quickstart
+
+```bash
+# build the demo knowledgebase (fictional company handbook, entities + relations)
+python examples/build_example.py
+
+# serve REST + the graph UI at http://127.0.0.1:8471
+# (note: start it from a normal terminal — servers launched inside an agent
+# sandbox get torn down and can't be reached from your browser)
+grag --db examples/knowledge.lbdb serve
+
+# or answer 3 demo questions end-to-end in the terminal
+python examples/demo_e2e.py
+```
+
+The UI: force-graph explorer (click = inspect, double-click = expand neighbors), Cypher console (Ctrl+Enter, graph/table results), schema sidebar, and a search bar that shows the exact grounding text an LLM would receive.
+
+## Use from an LLM harness (MCP)
+
+```bash
+grag --db knowledge.lbdb mcp
+```
+
+Cursor / `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "grag": {
+      "command": "grag",
+      "args": ["--db", "/absolute/path/knowledge.lbdb", "mcp"]
+    }
+  }
+}
+```
+
+Any MCP client gets these 7 tools:
+
+| tool | purpose |
+|---|---|
+| `describe_schema` | prompt-shaped schema: tables, properties, row counts, sample keys. Call before writing Cypher — kills hallucinated labels. |
+| `define_schema` | create node/rel tables (LLM designs the graph for a domain) |
+| `upsert_nodes` / `upsert_edges` | idempotent MERGE writes; `_source` provenance automatic |
+| `cypher_query` | read-only Cypher; errors come back with correction hints |
+| `search_knowledge` | hybrid BM25 + vector seeds → k-hop expansion → cited, token-budgeted context |
+| `get_context` | re-pack chosen node ids into a token budget |
+
+Errors are returned as `ERROR: ... HINT: ...` tool output so the model self-corrects in-loop.
+
+## Multiple projects / shared server
+
+One `.lbdb` = one isolated universe — no shared entities, no cross-db queries. Per-project DBs is the default pattern; multi-db serving is opt-in via `--db-dir` (single-db is unchanged).
+
+```bash
+grag --db-dir ~/kb serve    # one process serves every .lbdb in ~/kb
+```
+
+Every `/api/*` endpoint accepts `?db=<name>` or an `x-grag-db: <name>` header (query param wins). `GET /api/dbs` returns `{"dbs": ["alpha","beta"], "default": "alpha"}` (`{"dbs": [], "default": null}` in single-db mode). Without a selector the server prefers the file matching `db_path`'s name, else a lone `.lbdb`, else 400 with a hint; unknown name → 404 listing available DBs.
+
+For MCP, several IDE windows on one DB collide: stdio spawns a `grag mcp` process per client and LadybugDB allows only ONE process to write a given `.lbdb` ("Could not set lock"). One shared HTTP server avoids it — each window sends its project name via `x-grag-db`:
+
+```bash
+grag --db-dir ~/kb mcp --transport streamable-http --host 127.0.0.1 --port 8472
+```
+
+Cursor / `.cursor/mcp.json` (per window, one header per project):
+
+```json
+{
+  "mcpServers": {
+    "grag": {
+      "url": "http://127.0.0.1:8472/mcp",
+      "headers": { "x-grag-db": "project-a" }
+    }
+  }
+}
+```
+
+The server is localhost-only by default, and db names are routing hints, not auth — resolution rejects absolute paths and `..`. Single-db stdio (`grag --db knowledge.lbdb mcp`) remains the simple default.
+
+## Python API
+
+```python
+from grag import GragConfig
+from grag.service import GragService
+from grag.core.types import SearchRequest
+
+svc = GragService(GragConfig(db_path="knowledge.lbdb"))
+res = svc.search_knowledge(SearchRequest(query="who owns the ingestion gateway?", hops=1))
+print(res.context)        # cited subgraph text, ready for a prompt
+```
+
+Everything is also mirrored over REST: `POST /api/{query,search,context,ingest}`, `GET /api/{schema,graph/sample,health}`, `POST /api/{schema/define,nodes/upsert,edges/upsert}`.
+
+## Retrieval: hybrid + polar-split vectors
+
+1. Text properties get a native BM25 FTS index per searchable table.
+2. With an embedder configured, embeddings are written with a **polar decomposition**: magnitude `r` in one float property, direction `u` quantized by a swappable codec. Codes only generate candidates; final scores are exact fp32 rescore + graph rerank, so recall loss is bounded and measurable.
+3. Seeds (RRF-fused FTS+vector) expand k hops through the graph — structure compensates for aggressive quantization.
+
+Codec ladder (`grag bench` reproduces these numbers on a synthetic 1500-doc corpus):
+
+| codec | bytes/vec (dim 64) | recall@10 | note |
+|---|---|---|---|
+| `fp32` | 256 | 0.998 | baseline; native HNSW index |
+| `int8` | 68 | 0.998 | 4x smaller, near-zero loss |
+| `binary` | 8 | 0.476 | 32x, hamming scan + rescore |
+| `polar` | 14 | 0.766 | experimental PolarQuant-style angular codes (sine-power-law bit allocation, training-free) |
+
+Select with `GRAG_VECTOR_CODEC` / `GragConfig.vector_codec`. `polar` is opt-in; `int8` is the sweet spot today.
+
+## Configuration
+
+Env vars: `GRAG_DB_PATH`, `GRAG_BUFFER_POOL_MB` (default 256), `GRAG_VECTOR_CODEC`, `GRAG_TOKEN_BUDGET`, `GRAG_EMBED_PROVIDER` (`fastembed`|`remote`), `GRAG_EMBED_MODEL`, `GRAG_EMBED_DIM`, `GRAG_EMBED_BASE_URL`, `GRAG_EMBED_API_KEY_ENV`.
+
+## Performance budget
+
+Measured, not assumed — `tests/test_perf.py` guards cold start (< 2s), search latency, and RSS; `grag bench` reports recall + p50/p95 + RSS per codec. Design rules: no heavy deps in the default install, one process for API+UI, lazy embedder loading, default `LIMIT`s, hop caps, statement timeouts, token budgets everywhere.
+
+## Storage conventions
+
+- One `.lbdb` file per database. Properties starting with `_` are grag-internal.
+- Provenance: `_source`, `_created_at` on every table created via `define_schema`.
+- Vector columns (`embedding`, `_emb_r`, `_emb_code`, `_emb_model`) are added lazily by the retrieval layer.
+- `_grag_tables` registry powers introspection and canonical `Label:key` node ids.
+
+## Develop
+
+```bash
+python -m pytest tests/          # 160+ tests, ~10s
+grag bench                        # codec recall/latency/RSS table
+cd ui && npm run build            # rebuilds the UI into src/grag/api/static/
+```
+
+See **[CONTRIBUTING.md](CONTRIBUTING.md)** for the branching model (Gitflow-lite:
+`main` + `develop` + `feature`/`release`/`hotfix`), PR rules, and how releases are
+cut and published to PyPI.
+
+Known limits: embedded engine = single-writer; LadybugDB reserves a large *virtual* address space per open database (actual RSS stays within the buffer pool) — close `Engine`s you create; polar codec encode is Python-speed (fine at query time, slower at write time).

gragdb-0.1.0/README.md

@@ -0,0 +1,187 @@
+# grag
+
+**LLM-first graph knowledgebase.** One embedded Cypher engine ([LadybugDB](https://ladybugdb.com), the Kuzu successor), one file per database, zero daemons — wrapped in the tool contract LLMs actually need: schema introspection that anchors text-to-Cypher, idempotent upserts with provenance, hybrid FTS/vector search, and token-budgeted subgraph context for grounded, low-hallucination answers.
+
+*(**G**(raph)**RAG** — retrieval-augmented generation grounded in a graph.)*
+
+Not an enterprise platform. `pip install`, point an MCP client at it, done.
+
+## Why
+
+LLM answers hallucinate when retrieval returns isolated chunks. grag stores knowledge as a **graph** — entities, documents, and their relationships — so retrieval returns a connected, cited subgraph an LLM can reason over. The LLM can also *build* the graph: `define_schema` + `upsert_nodes/edges` are first-class tools, so "turn these docs into a knowledge graph" is a normal conversation, not a pipeline project.
+
+## Install
+
+**From PyPI** (ships the web UI):
+
+```bash
+pip install gragdb
+```
+
+Python 3.10–3.14; **3.13 recommended** (faster interpreter for the Python-side
+packing/serialization paths, and 3.10 reaches end-of-life in October 2026).
+
+**From source** (for development). Build the UI **first** — `pip install` needs the
+built bundle at `src/grag/api/static` (the wheel's force-include; see `pyproject.toml`):
+
+```bash
+cd ui && npm ci && npm run build && cd ..   # builds the UI into src/grag/api/static/
+pip install -e .            # core: engine, REST, MCP, FTS — no torch, no GPU stack
+pip install -e ".[dev]"     # tests
+pip install -e ".[embed-local]"   # optional: local embeddings (fastembed/ONNX, still no torch)
+pip install -e ".[embed-remote]"  # optional: OpenAI-compatible remote embeddings
+```
+
+Without an embedder, everything works FTS-only (BM25 is native to the engine).
+
+**Enabling semantic search:** install `embed-local`, then set `GRAG_EMBED_PROVIDER=fastembed`
+when serving. This uses ONNX Runtime — **no PyTorch** — so grag stays light (~50-100MB,
+model downloads once then works offline). Nodes are (re)embedded lazily on the next
+search whenever their embedding is NULL. First query downloads the model + embeds all
+nodes (seconds); steady state is ~300ms/query on CPU.
+
+```bash
+pip install -e ".[embed-local]"
+GRAG_EMBED_PROVIDER=fastembed grag --db knowledge.lbdb serve
+# optional: GRAG_EMBED_MODEL=BAAI/bge-base-en-v1.5 GRAG_EMBED_DIM=768
+```
+
+## Quickstart
+
+```bash
+# build the demo knowledgebase (fictional company handbook, entities + relations)
+python examples/build_example.py
+
+# serve REST + the graph UI at http://127.0.0.1:8471
+# (note: start it from a normal terminal — servers launched inside an agent
+# sandbox get torn down and can't be reached from your browser)
+grag --db examples/knowledge.lbdb serve
+
+# or answer 3 demo questions end-to-end in the terminal
+python examples/demo_e2e.py
+```
+
+The UI: force-graph explorer (click = inspect, double-click = expand neighbors), Cypher console (Ctrl+Enter, graph/table results), schema sidebar, and a search bar that shows the exact grounding text an LLM would receive.
+
+## Use from an LLM harness (MCP)
+
+```bash
+grag --db knowledge.lbdb mcp
+```
+
+Cursor / `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "grag": {
+      "command": "grag",
+      "args": ["--db", "/absolute/path/knowledge.lbdb", "mcp"]
+    }
+  }
+}
+```
+
+Any MCP client gets these 7 tools:
+
+| tool | purpose |
+|---|---|
+| `describe_schema` | prompt-shaped schema: tables, properties, row counts, sample keys. Call before writing Cypher — kills hallucinated labels. |
+| `define_schema` | create node/rel tables (LLM designs the graph for a domain) |
+| `upsert_nodes` / `upsert_edges` | idempotent MERGE writes; `_source` provenance automatic |
+| `cypher_query` | read-only Cypher; errors come back with correction hints |
+| `search_knowledge` | hybrid BM25 + vector seeds → k-hop expansion → cited, token-budgeted context |
+| `get_context` | re-pack chosen node ids into a token budget |
+
+Errors are returned as `ERROR: ... HINT: ...` tool output so the model self-corrects in-loop.
+
+## Multiple projects / shared server
+
+One `.lbdb` = one isolated universe — no shared entities, no cross-db queries. Per-project DBs is the default pattern; multi-db serving is opt-in via `--db-dir` (single-db is unchanged).
+
+```bash
+grag --db-dir ~/kb serve    # one process serves every .lbdb in ~/kb
+```
+
+Every `/api/*` endpoint accepts `?db=<name>` or an `x-grag-db: <name>` header (query param wins). `GET /api/dbs` returns `{"dbs": ["alpha","beta"], "default": "alpha"}` (`{"dbs": [], "default": null}` in single-db mode). Without a selector the server prefers the file matching `db_path`'s name, else a lone `.lbdb`, else 400 with a hint; unknown name → 404 listing available DBs.
+
+For MCP, several IDE windows on one DB collide: stdio spawns a `grag mcp` process per client and LadybugDB allows only ONE process to write a given `.lbdb` ("Could not set lock"). One shared HTTP server avoids it — each window sends its project name via `x-grag-db`:
+
+```bash
+grag --db-dir ~/kb mcp --transport streamable-http --host 127.0.0.1 --port 8472
+```
+
+Cursor / `.cursor/mcp.json` (per window, one header per project):
+
+```json
+{
+  "mcpServers": {
+    "grag": {
+      "url": "http://127.0.0.1:8472/mcp",
+      "headers": { "x-grag-db": "project-a" }
+    }
+  }
+}
+```
+
+The server is localhost-only by default, and db names are routing hints, not auth — resolution rejects absolute paths and `..`. Single-db stdio (`grag --db knowledge.lbdb mcp`) remains the simple default.
+
+## Python API
+
+```python
+from grag import GragConfig
+from grag.service import GragService
+from grag.core.types import SearchRequest
+
+svc = GragService(GragConfig(db_path="knowledge.lbdb"))
+res = svc.search_knowledge(SearchRequest(query="who owns the ingestion gateway?", hops=1))
+print(res.context)        # cited subgraph text, ready for a prompt
+```
+
+Everything is also mirrored over REST: `POST /api/{query,search,context,ingest}`, `GET /api/{schema,graph/sample,health}`, `POST /api/{schema/define,nodes/upsert,edges/upsert}`.
+
+## Retrieval: hybrid + polar-split vectors
+
+1. Text properties get a native BM25 FTS index per searchable table.
+2. With an embedder configured, embeddings are written with a **polar decomposition**: magnitude `r` in one float property, direction `u` quantized by a swappable codec. Codes only generate candidates; final scores are exact fp32 rescore + graph rerank, so recall loss is bounded and measurable.
+3. Seeds (RRF-fused FTS+vector) expand k hops through the graph — structure compensates for aggressive quantization.
+
+Codec ladder (`grag bench` reproduces these numbers on a synthetic 1500-doc corpus):
+
+| codec | bytes/vec (dim 64) | recall@10 | note |
+|---|---|---|---|
+| `fp32` | 256 | 0.998 | baseline; native HNSW index |
+| `int8` | 68 | 0.998 | 4x smaller, near-zero loss |
+| `binary` | 8 | 0.476 | 32x, hamming scan + rescore |
+| `polar` | 14 | 0.766 | experimental PolarQuant-style angular codes (sine-power-law bit allocation, training-free) |
+
+Select with `GRAG_VECTOR_CODEC` / `GragConfig.vector_codec`. `polar` is opt-in; `int8` is the sweet spot today.
+
+## Configuration
+
+Env vars: `GRAG_DB_PATH`, `GRAG_BUFFER_POOL_MB` (default 256), `GRAG_VECTOR_CODEC`, `GRAG_TOKEN_BUDGET`, `GRAG_EMBED_PROVIDER` (`fastembed`|`remote`), `GRAG_EMBED_MODEL`, `GRAG_EMBED_DIM`, `GRAG_EMBED_BASE_URL`, `GRAG_EMBED_API_KEY_ENV`.
+
+## Performance budget
+
+Measured, not assumed — `tests/test_perf.py` guards cold start (< 2s), search latency, and RSS; `grag bench` reports recall + p50/p95 + RSS per codec. Design rules: no heavy deps in the default install, one process for API+UI, lazy embedder loading, default `LIMIT`s, hop caps, statement timeouts, token budgets everywhere.
+
+## Storage conventions
+
+- One `.lbdb` file per database. Properties starting with `_` are grag-internal.
+- Provenance: `_source`, `_created_at` on every table created via `define_schema`.
+- Vector columns (`embedding`, `_emb_r`, `_emb_code`, `_emb_model`) are added lazily by the retrieval layer.
+- `_grag_tables` registry powers introspection and canonical `Label:key` node ids.
+
+## Develop
+
+```bash
+python -m pytest tests/          # 160+ tests, ~10s
+grag bench                        # codec recall/latency/RSS table
+cd ui && npm run build            # rebuilds the UI into src/grag/api/static/
+```
+
+See **[CONTRIBUTING.md](CONTRIBUTING.md)** for the branching model (Gitflow-lite:
+`main` + `develop` + `feature`/`release`/`hotfix`), PR rules, and how releases are
+cut and published to PyPI.
+
+Known limits: embedded engine = single-writer; LadybugDB reserves a large *virtual* address space per open database (actual RSS stays within the buffer pool) — close `Engine`s you create; polar codec encode is Python-speed (fine at query time, slower at write time).

gragdb-0.1.0/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "gragdb"
+version = "0.1.0"
+description = "LLM-first graph knowledgebase: embedded Cypher engine, MCP tool contract, GraphRAG retrieval"
+readme = "README.md"
+requires-python = ">=3.10,<3.15"
+license = { text = "MIT" }
+dependencies = [
+    "ladybug>=0.19",
+    "fastapi>=0.110",
+    "uvicorn>=0.29",
+    "mcp>=2.0",
+    "pydantic>=2.6",
+    "numpy>=1.26",
+]
+
+[project.optional-dependencies]
+embed-local = ["fastembed>=0.4"]
+embed-remote = ["httpx>=0.27"]
+dev = ["pytest>=8.0", "httpx>=0.27", "pyyaml>=6.0"]
+
+[project.scripts]
+grag = "grag.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/grag"]
+
+# The built web UI lives in src/grag/api/static but is gitignored (it's a build
+# artifact of ui/), so the default wheel omits it. Force-include it so a
+# `pip install gragdb` ships the working UI. NOTE: force-include makes the dir
+# REQUIRED at build time — so build the UI first (cd ui && npm ci && npm run
+# build) before `pip install .` / `pip install -e .` / `python -m build`. CI and
+# the publish workflow both do this; an editable install only *serves* the UI if
+# it's been built.
+[tool.hatch.build.targets.wheel.force-include]
+"src/grag/api/static" = "grag/api/static"
+
+[tool.hatch.build.targets.sdist]
+# Don't let .gitignore exclude files from the sdist: src/grag/api/static is a
+# gitignored *build artifact* that we DO ship when present. include (below)
+# governs instead. The sdist lists it WITHOUT a trailing slash so it's an
+# optional prefix (tolerated when absent); the wheel's force-include above is
+# what *requires* it for distribution builds.
+ignore-vcs = true
+include = [
+    "src/grag",
+    "src/grag/api/static",
+    "ui",
+    "README.md",
+    "LICENSE",
+    "pyproject.toml",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q"

gragdb-0.1.0/src/grag/__init__.py

@@ -0,0 +1,8 @@
+"""grag — LLM-first graph knowledgebase."""
+
+__version__ = "0.1.0"
+
+from grag.config import GragConfig
+from grag.core.engine import Engine
+
+__all__ = ["GragConfig", "Engine", "__version__"]

gragdb-0.1.0/src/grag/api/__init__.py

@@ -0,0 +1 @@
+"""grag REST API (FastAPI)."""