From 7aa300709f36e35fa7024fefac9eeb426f3c8af6 Mon Sep 17 00:00:00 2001 From: Gal Shubeli Date: Sun, 7 Jun 2026 15:03:49 +0300 Subject: [PATCH 1/4] feat: add FalkorDB export backend (#1175) Adds FalkorDB as a sibling option to the existing Neo4j sink, selected via `graphify export falkordb [--push redis://localhost:6379]`. - New push_to_falkordb() in graphify/export.py mirrors push_to_neo4j; FalkorDB is OpenCypher-compatible so the MERGE/SET upsert queries are identical. - export falkordb subcommand wired in graphify/__main__.py (cypher.txt when no --push, direct push otherwise). Auth is optional; target graph defaults to "graphify". - falkordb optional extra in pyproject.toml (and in the all extra). - Tests: CLI cypher generation (CI-safe) + real-FalkorDB integration tests that skip when no instance is reachable. - README extras table + command reference and CHANGELOG updated. --- CHANGELOG.md | 1 + README.md | 3 + graphify/__main__.py | 20 ++++++- graphify/export.py | 95 ++++++++++++++++++++++++++++++ pyproject.toml | 3 +- tests/test_cli_export.py | 13 ++++ tests/test_falkordb_integration.py | 91 ++++++++++++++++++++++++++++ 7 files changed, 223 insertions(+), 3 deletions(-) create mode 100644 tests/test_falkordb_integration.py diff --git a/CHANGELOG.md b/CHANGELOG.md index b37a299f6..0a9a37f48 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,7 @@ Full release notes with details on each version: [GitHub Releases](https://githu ## 0.8.33 (2026-06-06) +- Feat: FalkorDB export backend — sibling to Neo4j, selected via `graphify export falkordb [--push redis://localhost:6379]`. FalkorDB is OpenCypher-compatible, so the MERGE/SET upsert queries match the Neo4j path; auth is optional and the target graph defaults to `graphify`. Install with `uv tool install "graphifyy[falkordb]"` (#1175). - Feat: install banner — `graphify install` now prints an amber knowledge-graph brain in the terminal (TTY-only, silent in CI/pipes, never raises). - Fix: Python `from pkg import submod` package-form imports now resolve to a file-level `imports_from` edge to the submodule file when it exists on disk. Previously these imports produced zero edges, leaving test files as disconnected islands in the graph (up to 66% of test nodes in some corpora). The fix lives in the symbol-resolution post-pass which has filesystem access (#1146). - Fix: builtin type-annotation nodes (`str`, `int`, `bool`, `float`, `bytes`, `MagicMock`, `Mock`, `AsyncMock`, etc.) no longer appear as graph nodes or accumulate edges. They were being created via the annotation walker whenever used as parameter or return types, inflating degree counts ~25% and displacing real abstractions from god-node rankings. A new `_PYTHON_ANNOTATION_NOISE` filter suppresses them at extraction time; `god_nodes` also filters them as a defense for pre-existing graphs (#1147). diff --git a/README.md b/README.md index f91ad7988..d2fe24ac6 100644 --- a/README.md +++ b/README.md @@ -162,6 +162,7 @@ Install only what you need: | `video` | Video/audio transcription (faster-whisper + yt-dlp) | `uv tool install "graphifyy[video]"` | | `mcp` | MCP stdio server | `uv tool install "graphifyy[mcp]"` | | `neo4j` | Neo4j push support | `uv tool install "graphifyy[neo4j]"` | +| `falkordb` | FalkorDB push support | `uv tool install "graphifyy[falkordb]"` | | `svg` | SVG graph export | `uv tool install "graphifyy[svg]"` | | `leiden` | Leiden community detection (Python < 3.13 only) | `uv tool install "graphifyy[leiden]"` | | `ollama` | Ollama local inference | `uv tool install "graphifyy[ollama]"` | @@ -496,6 +497,8 @@ graphify install # overwrites the skill file /graphify ./raw --graphml # export for Gephi / yEd /graphify ./raw --neo4j # generate cypher.txt for Neo4j /graphify ./raw --neo4j-push bolt://localhost:7687 +graphify export falkordb # generate cypher.txt (FalkorDB is OpenCypher-compatible) +graphify export falkordb --push redis://localhost:6379 # push directly to a running FalkorDB /graphify ./raw --watch # auto-sync as files change /graphify ./raw --mcp # start MCP stdio server diff --git a/graphify/__main__.py b/graphify/__main__.py index 6766486d4..bbf88b3c1 100644 --- a/graphify/__main__.py +++ b/graphify/__main__.py @@ -3370,7 +3370,7 @@ def _load_graph(p: str): elif cmd == "export": subcmd = sys.argv[2] if len(sys.argv) > 2 else "" - if subcmd not in ("html", "callflow-html", "obsidian", "wiki", "svg", "graphml", "neo4j"): + if subcmd not in ("html", "callflow-html", "obsidian", "wiki", "svg", "graphml", "neo4j", "falkordb"): print("Usage: graphify export ", file=sys.stderr) print(" html [--graph PATH] [--labels PATH] [--node-limit N] [--no-viz]", file=sys.stderr) print(" callflow-html [GRAPH|DIR] [--graph PATH] [--labels PATH] [--report PATH] [--sections PATH] [--output HTML]", file=sys.stderr) @@ -3381,6 +3381,8 @@ def _load_graph(p: str): print(" graphml [--graph PATH]", file=sys.stderr) print(" neo4j [--graph PATH] [--push URI] [--user U] [--password P]", file=sys.stderr) print(" (or set NEO4J_PASSWORD instead of --password to keep it off argv)", file=sys.stderr) + print(" falkordb [--graph PATH] [--push URI] [--user U] [--password P]", file=sys.stderr) + print(" (or set FALKORDB_PASSWORD instead of --password to keep it off argv)", file=sys.stderr) sys.exit(1) # Parse shared args @@ -3407,7 +3409,9 @@ def _load_graph(p: str): # F-031: prefer the NEO4J_PASSWORD env var so the password never # appears on argv (visible in `ps` output / shell history). The # explicit --password flag still overrides it for compatibility. - neo4j_password: str | None = os.environ.get("NEO4J_PASSWORD") or None + neo4j_password: str | None = ( + os.environ.get("NEO4J_PASSWORD") or os.environ.get("FALKORDB_PASSWORD") or None + ) i = 0 while i < len(args): a = args[i] @@ -3626,6 +3630,18 @@ def _load_graph(p: str): _to_cypher(G, str(out_dir / "cypher.txt")) print(f"cypher.txt written - import with: cypher-shell < {out_dir}/cypher.txt") + elif subcmd == "falkordb": + if neo4j_uri: + from graphify.export import push_to_falkordb as _push + result = _push(G, uri=neo4j_uri, user=neo4j_user, + password=neo4j_password, communities=communities) + print(f"Pushed to FalkorDB: {result['nodes']} nodes, {result['edges']} edges") + else: + from graphify.export import to_cypher as _to_cypher + _to_cypher(G, str(out_dir / "cypher.txt")) + print(f"cypher.txt written - FalkorDB is OpenCypher-compatible; " + f"import with: redis-cli -x GRAPH.QUERY graphify < {out_dir}/cypher.txt") + elif cmd == "benchmark": from graphify.benchmark import run_benchmark, print_benchmark diff --git a/graphify/export.py b/graphify/export.py index 425cced6b..a425ecd53 100644 --- a/graphify/export.py +++ b/graphify/export.py @@ -1309,6 +1309,101 @@ def _safe_label(label: str) -> str: return {"nodes": nodes_pushed, "edges": edges_pushed} +def push_to_falkordb( + G: nx.Graph, + uri: str, + user: str | None = None, + password: str | None = None, + communities: dict[int, list[str]] | None = None, + graph_name: str = "graphify", +) -> dict[str, int]: + """Push graph directly to a running FalkorDB instance via the Python SDK. + + Requires: pip install falkordb + + FalkorDB is OpenCypher-compatible, so the MERGE/SET upsert queries are + identical to push_to_neo4j. Differences from the Neo4j path: + - connects with FalkorDB(host, port, username, password) instead of a bolt + driver; the URI is parsed for host/port (default port 6379, scheme + defaults to redis:// when omitted, e.g. "localhost:6379"). + - a named graph is selected via db.select_graph(graph_name) (default + "graphify"); FalkorDB keys each graph by name in the same instance. + - queries run via graph.query(cypher, params) - there is no session object. + - auth is optional (FalkorDB runs without credentials by default), so user + and password may be None. + - no APOC: the Neo4j path does not use APOC either, so nothing to port. + + Uses MERGE so re-running is safe - nodes and edges are upserted, not + duplicated. Returns a dict with counts of nodes and edges pushed. + """ + try: + from falkordb import FalkorDB + except ImportError as e: + raise ImportError( + "falkordb SDK not installed. Run: pip install falkordb" + ) from e + + from urllib.parse import urlparse + + node_community = _node_community_map(communities) if communities else {} + + def _safe_rel(relation: str) -> str: + return re.sub(r"[^A-Z0-9_]", "_", relation.upper().replace(" ", "_").replace("-", "_")) or "RELATED_TO" + + def _safe_label(label: str) -> str: + """Sanitize a FalkorDB node label to prevent Cypher injection.""" + sanitized = re.sub(r"[^A-Za-z0-9_]", "", label) + return sanitized if sanitized else "Entity" + + parsed = urlparse(uri if "://" in uri else f"redis://{uri}") + # FalkorDB auth is optional. Only send credentials when a password is + # provided; otherwise connect anonymously and ignore any bolt-style default + # username (e.g. Neo4j's "neo4j"), which FalkorDB rejects as an unknown ACL + # user. Credentials embedded in the URI take precedence over the args. + connect_user = parsed.username or (user if password else None) + connect_password = parsed.password or (password or None) + db = FalkorDB( + host=parsed.hostname or "localhost", + port=parsed.port or 6379, + username=connect_user, + password=connect_password, + ) + graph = db.select_graph(graph_name) + nodes_pushed = 0 + edges_pushed = 0 + + for node_id, data in G.nodes(data=True): + props = { + k: v for k, v in data.items() + if isinstance(v, (str, int, float, bool)) and not k.startswith("_") + } + props["id"] = node_id + cid = node_community.get(node_id) + if cid is not None: + props["community"] = cid + ftype = _safe_label(data.get("file_type", "Entity").capitalize()) + graph.query( + f"MERGE (n:{ftype} {{id: $id}}) SET n += $props", + {"id": node_id, "props": props}, + ) + nodes_pushed += 1 + + for u, v, data in G.edges(data=True): + rel = _safe_rel(data.get("relation", "RELATED_TO")) + props = { + k: v for k, v in data.items() + if isinstance(v, (str, int, float, bool)) and not k.startswith("_") + } + graph.query( + f"MATCH (a {{id: $src}}), (b {{id: $tgt}}) " + f"MERGE (a)-[r:{rel}]->(b) SET r += $props", + {"src": u, "tgt": v, "props": props}, + ) + edges_pushed += 1 + + return {"nodes": nodes_pushed, "edges": edges_pushed} + + def to_graphml( G: nx.Graph, communities: dict[int, list[str]], diff --git a/pyproject.toml b/pyproject.toml index 64f8f78e7..d498dc2d4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -50,6 +50,7 @@ Issues = "https://github.com/safishamsi/graphify/issues" [project.optional-dependencies] mcp = ["mcp"] neo4j = ["neo4j"] +falkordb = ["falkordb"] pdf = ["pypdf", "markdownify"] watch = ["watchdog"] svg = ["matplotlib", "numpy>=2.0; python_version >= '3.13'"] @@ -71,7 +72,7 @@ sql = ["tree-sitter-sql"] # avoids breaking the default `uv tool install graphifyy` for everyone (#1104). dm = ["tree-sitter-dm"] terraform = ["tree-sitter-hcl"] -all = ["mcp", "neo4j", "pypdf", "markdownify", "watchdog", "graspologic; python_version < '3.13'", "python-docx", "openpyxl", "faster-whisper; python_version >= '3.11'", "yt-dlp", "matplotlib", "numpy>=2.0; python_version >= '3.13'", "openai", "tiktoken", "boto3", "anthropic", "tree-sitter-sql", "jieba", "tree-sitter-dm", "tree-sitter-hcl"] +all = ["mcp", "neo4j", "falkordb", "pypdf", "markdownify", "watchdog", "graspologic; python_version < '3.13'", "python-docx", "openpyxl", "faster-whisper; python_version >= '3.11'", "yt-dlp", "matplotlib", "numpy>=2.0; python_version >= '3.13'", "openai", "tiktoken", "boto3", "anthropic", "tree-sitter-sql", "jieba", "tree-sitter-dm", "tree-sitter-hcl"] [project.scripts] graphify = "graphify.__main__:main" diff --git a/tests/test_cli_export.py b/tests/test_cli_export.py index 942dbcf26..e8a5bc25e 100644 --- a/tests/test_cli_export.py +++ b/tests/test_cli_export.py @@ -154,6 +154,19 @@ def test_export_neo4j_creates_cypher(tmp_path): assert "MERGE" in content or "CREATE" in content +# ── graphify export falkordb (cypher) ──────────────────────────────────────── + +def test_export_falkordb_creates_cypher(tmp_path): + _make_graph(tmp_path) + r = _run(["export", "falkordb"], tmp_path) + assert r.returncode == 0, r.stderr + cypher = tmp_path / "graphify-out" / "cypher.txt" + assert cypher.exists() + assert cypher.stat().st_size > 0 + content = cypher.read_text() + assert "MERGE" in content or "CREATE" in content + + # ── graphify query ─────────────────────────────────────────────────────────── def test_query_returns_output(tmp_path): diff --git a/tests/test_falkordb_integration.py b/tests/test_falkordb_integration.py new file mode 100644 index 000000000..649e1d274 --- /dev/null +++ b/tests/test_falkordb_integration.py @@ -0,0 +1,91 @@ +"""Integration test for push_to_falkordb against a real FalkorDB instance. + +Runs for real against `falkordb/falkordb:latest`: + + docker run -d -p 6379:6379 falkordb/falkordb:latest + uv run pytest tests/test_falkordb_integration.py -q + +The test auto-skips when the `falkordb` SDK is not installed or no FalkorDB is +reachable, so it is a no-op in the default CI (which runs no external services). +Host/port are overridable via FALKORDB_HOST / FALKORDB_PORT. +""" +from __future__ import annotations + +import json +import os +from pathlib import Path + +import pytest + +falkordb = pytest.importorskip("falkordb") + +FIXTURES = Path(__file__).parent / "fixtures" +HOST = os.environ.get("FALKORDB_HOST", "localhost") +PORT = int(os.environ.get("FALKORDB_PORT", "6379")) +GRAPH_NAME = "graphify_test" + + +def _connect(): + """Return a connected FalkorDB client, or skip if none is reachable.""" + try: + db = falkordb.FalkorDB(host=HOST, port=PORT) + db.connection.ping() + return db + except Exception as e: # pragma: no cover - depends on local environment + pytest.skip(f"no FalkorDB reachable at {HOST}:{PORT} ({e})") + + +@pytest.fixture() +def db(): + client = _connect() + # Start from a clean slate and clean up afterwards. + try: + client.select_graph(GRAPH_NAME).delete() + except Exception: + pass + yield client + try: + client.select_graph(GRAPH_NAME).delete() + except Exception: + pass + + +def test_push_to_falkordb_creates_expected_graph(db): + from graphify.build import build_from_json + from graphify.export import push_to_falkordb + + extraction = json.loads((FIXTURES / "extraction.json").read_text()) + G = build_from_json(extraction) + + result = push_to_falkordb( + G, uri=f"{HOST}:{PORT}", graph_name=GRAPH_NAME + ) + + assert result["nodes"] == G.number_of_nodes() + assert result["edges"] == G.number_of_edges() + + graph = db.select_graph(GRAPH_NAME) + node_count = graph.query("MATCH (n) RETURN count(n)").result_set[0][0] + edge_count = graph.query("MATCH ()-[r]->() RETURN count(r)").result_set[0][0] + + assert node_count == G.number_of_nodes() + assert edge_count == G.number_of_edges() + + +def test_push_to_falkordb_is_idempotent(db): + """MERGE-based push is safe to re-run - counts must not grow.""" + from graphify.build import build_from_json + from graphify.export import push_to_falkordb + + extraction = json.loads((FIXTURES / "extraction.json").read_text()) + G = build_from_json(extraction) + + push_to_falkordb(G, uri=f"{HOST}:{PORT}", graph_name=GRAPH_NAME) + push_to_falkordb(G, uri=f"{HOST}:{PORT}", graph_name=GRAPH_NAME) + + graph = db.select_graph(GRAPH_NAME) + node_count = graph.query("MATCH (n) RETURN count(n)").result_set[0][0] + edge_count = graph.query("MATCH ()-[r]->() RETURN count(r)").result_set[0][0] + + assert node_count == G.number_of_nodes() + assert edge_count == G.number_of_edges() From bf0ace17596888fec4e06aafb7b202523985a882 Mon Sep 17 00:00:00 2001 From: Gal Shubeli Date: Mon, 8 Jun 2026 12:56:20 +0300 Subject: [PATCH 2/4] feat: add --falkordb/--falkordb-push skill shorthands, use falkordb:// URI Makes the FalkorDB option a first-class sibling of Neo4j in the agent skill, not just the export CLI: - --falkordb / --falkordb-push shorthands documented in core.md + the shared exports.md reference, so they render into all modular platform skills and read exactly like --neo4j / --neo4j-push. (The aider/devin monoliths are diff-frozen vs v8 by skillgen's roundtrip guard, so they are left untouched.) - README command reference switched to the /graphify ./raw --falkordb-push form. - Documented URI scheme is now falkordb://localhost:6379; the scheme is only informational (host/port are parsed out), so redis:// or a bare host:port remain equivalent. Regenerated skill artifacts + expected/ snapshots. --- CHANGELOG.md | 2 +- README.md | 4 ++-- graphify/export.py | 5 +++-- graphify/skill-amp.md | 6 ++++-- graphify/skill-claw.md | 6 ++++-- graphify/skill-codex.md | 6 ++++-- graphify/skill-copilot.md | 6 ++++-- graphify/skill-droid.md | 6 ++++-- graphify/skill-kilo.md | 6 ++++-- graphify/skill-kiro.md | 6 ++++-- graphify/skill-opencode.md | 6 ++++-- graphify/skill-pi.md | 6 ++++-- graphify/skill-trae.md | 6 ++++-- graphify/skill-vscode.md | 6 ++++-- graphify/skill-windows.md | 6 ++++-- graphify/skill.md | 6 ++++-- graphify/skills/amp/references/exports.md | 18 +++++++++++++++++- graphify/skills/claude/references/exports.md | 18 +++++++++++++++++- graphify/skills/claw/references/exports.md | 18 +++++++++++++++++- graphify/skills/codex/references/exports.md | 18 +++++++++++++++++- graphify/skills/copilot/references/exports.md | 18 +++++++++++++++++- graphify/skills/droid/references/exports.md | 18 +++++++++++++++++- graphify/skills/kilo/references/exports.md | 18 +++++++++++++++++- graphify/skills/kiro/references/exports.md | 18 +++++++++++++++++- graphify/skills/opencode/references/exports.md | 18 +++++++++++++++++- graphify/skills/pi/references/exports.md | 18 +++++++++++++++++- graphify/skills/trae/references/exports.md | 18 +++++++++++++++++- graphify/skills/vscode/references/exports.md | 18 +++++++++++++++++- graphify/skills/windows/references/exports.md | 18 +++++++++++++++++- tools/skillgen/expected/graphify__skill-amp.md | 6 ++++-- .../skillgen/expected/graphify__skill-claw.md | 6 ++++-- .../skillgen/expected/graphify__skill-codex.md | 6 ++++-- .../expected/graphify__skill-copilot.md | 6 ++++-- .../skillgen/expected/graphify__skill-droid.md | 6 ++++-- .../skillgen/expected/graphify__skill-kilo.md | 6 ++++-- .../skillgen/expected/graphify__skill-kiro.md | 6 ++++-- .../expected/graphify__skill-opencode.md | 6 ++++-- tools/skillgen/expected/graphify__skill-pi.md | 6 ++++-- .../skillgen/expected/graphify__skill-trae.md | 6 ++++-- .../expected/graphify__skill-vscode.md | 6 ++++-- .../expected/graphify__skill-windows.md | 6 ++++-- tools/skillgen/expected/graphify__skill.md | 6 ++++-- ...aphify__skills__amp__references__exports.md | 18 +++++++++++++++++- ...ify__skills__claude__references__exports.md | 18 +++++++++++++++++- ...phify__skills__claw__references__exports.md | 18 +++++++++++++++++- ...hify__skills__codex__references__exports.md | 18 +++++++++++++++++- ...fy__skills__copilot__references__exports.md | 18 +++++++++++++++++- ...hify__skills__droid__references__exports.md | 18 +++++++++++++++++- ...phify__skills__kilo__references__exports.md | 18 +++++++++++++++++- ...phify__skills__kiro__references__exports.md | 18 +++++++++++++++++- ...y__skills__opencode__references__exports.md | 18 +++++++++++++++++- ...raphify__skills__pi__references__exports.md | 18 +++++++++++++++++- ...phify__skills__trae__references__exports.md | 18 +++++++++++++++++- ...ify__skills__vscode__references__exports.md | 18 +++++++++++++++++- ...fy__skills__windows__references__exports.md | 18 +++++++++++++++++- tools/skillgen/fragments/core/core.md | 6 ++++-- .../fragments/references/shared/exports.md | 18 +++++++++++++++++- 57 files changed, 573 insertions(+), 86 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0a9a37f48..e659c9567 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,7 +4,7 @@ Full release notes with details on each version: [GitHub Releases](https://githu ## 0.8.33 (2026-06-06) -- Feat: FalkorDB export backend — sibling to Neo4j, selected via `graphify export falkordb [--push redis://localhost:6379]`. FalkorDB is OpenCypher-compatible, so the MERGE/SET upsert queries match the Neo4j path; auth is optional and the target graph defaults to `graphify`. Install with `uv tool install "graphifyy[falkordb]"` (#1175). +- Feat: FalkorDB export backend — sibling to Neo4j, selected via `graphify export falkordb [--push falkordb://localhost:6379]`. FalkorDB is OpenCypher-compatible, so the MERGE/SET upsert queries match the Neo4j path; auth is optional and the target graph defaults to `graphify`. Install with `uv tool install "graphifyy[falkordb]"` (#1175). - Feat: install banner — `graphify install` now prints an amber knowledge-graph brain in the terminal (TTY-only, silent in CI/pipes, never raises). - Fix: Python `from pkg import submod` package-form imports now resolve to a file-level `imports_from` edge to the submodule file when it exists on disk. Previously these imports produced zero edges, leaving test files as disconnected islands in the graph (up to 66% of test nodes in some corpora). The fix lives in the symbol-resolution post-pass which has filesystem access (#1146). - Fix: builtin type-annotation nodes (`str`, `int`, `bool`, `float`, `bytes`, `MagicMock`, `Mock`, `AsyncMock`, etc.) no longer appear as graph nodes or accumulate edges. They were being created via the annotation walker whenever used as parameter or return types, inflating degree counts ~25% and displacing real abstractions from god-node rankings. A new `_PYTHON_ANNOTATION_NOISE` filter suppresses them at extraction time; `god_nodes` also filters them as a defense for pre-existing graphs (#1147). diff --git a/README.md b/README.md index d2fe24ac6..40c411aa0 100644 --- a/README.md +++ b/README.md @@ -497,8 +497,8 @@ graphify install # overwrites the skill file /graphify ./raw --graphml # export for Gephi / yEd /graphify ./raw --neo4j # generate cypher.txt for Neo4j /graphify ./raw --neo4j-push bolt://localhost:7687 -graphify export falkordb # generate cypher.txt (FalkorDB is OpenCypher-compatible) -graphify export falkordb --push redis://localhost:6379 # push directly to a running FalkorDB +/graphify ./raw --falkordb # generate cypher.txt for FalkorDB +/graphify ./raw --falkordb-push falkordb://localhost:6379 /graphify ./raw --watch # auto-sync as files change /graphify ./raw --mcp # start MCP stdio server diff --git a/graphify/export.py b/graphify/export.py index a425ecd53..05b3fea23 100644 --- a/graphify/export.py +++ b/graphify/export.py @@ -1324,8 +1324,9 @@ def push_to_falkordb( FalkorDB is OpenCypher-compatible, so the MERGE/SET upsert queries are identical to push_to_neo4j. Differences from the Neo4j path: - connects with FalkorDB(host, port, username, password) instead of a bolt - driver; the URI is parsed for host/port (default port 6379, scheme - defaults to redis:// when omitted, e.g. "localhost:6379"). + driver; only the host/port are read from the URI, so the scheme is + informational - "falkordb://localhost:6379", "redis://localhost:6379" + and a bare "localhost:6379" are all equivalent (default port 6379). - a named graph is selected via db.select_graph(graph_name) (default "graphify"); FalkorDB keys each graph by name in the same instance. - queries run via graph.query(cypher, params) - there is no session object. diff --git a/graphify/skill-amp.md b/graphify/skill-amp.md index 9cad76fc7..fb642d1b9 100644 --- a/graphify/skill-amp.md +++ b/graphify/skill-amp.md @@ -27,6 +27,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -475,9 +477,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/graphify/skill-claw.md b/graphify/skill-claw.md index bad0a0d54..cc00d31fa 100644 --- a/graphify/skill-claw.md +++ b/graphify/skill-claw.md @@ -27,6 +27,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -478,9 +480,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/graphify/skill-codex.md b/graphify/skill-codex.md index b9a70f06a..3259bc217 100644 --- a/graphify/skill-codex.md +++ b/graphify/skill-codex.md @@ -27,6 +27,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -475,9 +477,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/graphify/skill-copilot.md b/graphify/skill-copilot.md index bad0a0d54..cc00d31fa 100644 --- a/graphify/skill-copilot.md +++ b/graphify/skill-copilot.md @@ -27,6 +27,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -478,9 +480,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/graphify/skill-droid.md b/graphify/skill-droid.md index 6c965c679..b0f36e9d1 100644 --- a/graphify/skill-droid.md +++ b/graphify/skill-droid.md @@ -27,6 +27,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -475,9 +477,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/graphify/skill-kilo.md b/graphify/skill-kilo.md index 8bc6d5369..0fce87864 100644 --- a/graphify/skill-kilo.md +++ b/graphify/skill-kilo.md @@ -27,6 +27,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -478,9 +480,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/graphify/skill-kiro.md b/graphify/skill-kiro.md index 796ad8ca5..fe398f0c9 100644 --- a/graphify/skill-kiro.md +++ b/graphify/skill-kiro.md @@ -26,6 +26,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -477,9 +479,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/graphify/skill-opencode.md b/graphify/skill-opencode.md index 6c4f20864..ff5eb0b38 100644 --- a/graphify/skill-opencode.md +++ b/graphify/skill-opencode.md @@ -27,6 +27,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -470,9 +472,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/graphify/skill-pi.md b/graphify/skill-pi.md index 796ad8ca5..fe398f0c9 100644 --- a/graphify/skill-pi.md +++ b/graphify/skill-pi.md @@ -26,6 +26,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -477,9 +479,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/graphify/skill-trae.md b/graphify/skill-trae.md index 8ba7c66f6..df963642a 100644 --- a/graphify/skill-trae.md +++ b/graphify/skill-trae.md @@ -27,6 +27,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -476,9 +478,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/graphify/skill-vscode.md b/graphify/skill-vscode.md index 7be667ca9..4d9736ddc 100644 --- a/graphify/skill-vscode.md +++ b/graphify/skill-vscode.md @@ -27,6 +27,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -474,9 +476,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/graphify/skill-windows.md b/graphify/skill-windows.md index a15480dce..d8adc0018 100644 --- a/graphify/skill-windows.md +++ b/graphify/skill-windows.md @@ -27,6 +27,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -500,9 +502,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/graphify/skill.md b/graphify/skill.md index 4e9827b13..ec9c5dd88 100644 --- a/graphify/skill.md +++ b/graphify/skill.md @@ -27,6 +27,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -478,9 +480,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/graphify/skills/amp/references/exports.md b/graphify/skills/amp/references/exports.md index 3750ff23b..5c357d385 100644 --- a/graphify/skills/amp/references/exports.md +++ b/graphify/skills/amp/references/exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/graphify/skills/claude/references/exports.md b/graphify/skills/claude/references/exports.md index 3750ff23b..5c357d385 100644 --- a/graphify/skills/claude/references/exports.md +++ b/graphify/skills/claude/references/exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/graphify/skills/claw/references/exports.md b/graphify/skills/claw/references/exports.md index 3750ff23b..5c357d385 100644 --- a/graphify/skills/claw/references/exports.md +++ b/graphify/skills/claw/references/exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/graphify/skills/codex/references/exports.md b/graphify/skills/codex/references/exports.md index 3750ff23b..5c357d385 100644 --- a/graphify/skills/codex/references/exports.md +++ b/graphify/skills/codex/references/exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/graphify/skills/copilot/references/exports.md b/graphify/skills/copilot/references/exports.md index 3750ff23b..5c357d385 100644 --- a/graphify/skills/copilot/references/exports.md +++ b/graphify/skills/copilot/references/exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/graphify/skills/droid/references/exports.md b/graphify/skills/droid/references/exports.md index 3750ff23b..5c357d385 100644 --- a/graphify/skills/droid/references/exports.md +++ b/graphify/skills/droid/references/exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/graphify/skills/kilo/references/exports.md b/graphify/skills/kilo/references/exports.md index 3750ff23b..5c357d385 100644 --- a/graphify/skills/kilo/references/exports.md +++ b/graphify/skills/kilo/references/exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/graphify/skills/kiro/references/exports.md b/graphify/skills/kiro/references/exports.md index 3750ff23b..5c357d385 100644 --- a/graphify/skills/kiro/references/exports.md +++ b/graphify/skills/kiro/references/exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/graphify/skills/opencode/references/exports.md b/graphify/skills/opencode/references/exports.md index 3750ff23b..5c357d385 100644 --- a/graphify/skills/opencode/references/exports.md +++ b/graphify/skills/opencode/references/exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/graphify/skills/pi/references/exports.md b/graphify/skills/pi/references/exports.md index 3750ff23b..5c357d385 100644 --- a/graphify/skills/pi/references/exports.md +++ b/graphify/skills/pi/references/exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/graphify/skills/trae/references/exports.md b/graphify/skills/trae/references/exports.md index 3750ff23b..5c357d385 100644 --- a/graphify/skills/trae/references/exports.md +++ b/graphify/skills/trae/references/exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/graphify/skills/vscode/references/exports.md b/graphify/skills/vscode/references/exports.md index 3750ff23b..5c357d385 100644 --- a/graphify/skills/vscode/references/exports.md +++ b/graphify/skills/vscode/references/exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/graphify/skills/windows/references/exports.md b/graphify/skills/windows/references/exports.md index 3750ff23b..5c357d385 100644 --- a/graphify/skills/windows/references/exports.md +++ b/graphify/skills/windows/references/exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/tools/skillgen/expected/graphify__skill-amp.md b/tools/skillgen/expected/graphify__skill-amp.md index 9cad76fc7..fb642d1b9 100644 --- a/tools/skillgen/expected/graphify__skill-amp.md +++ b/tools/skillgen/expected/graphify__skill-amp.md @@ -27,6 +27,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -475,9 +477,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/tools/skillgen/expected/graphify__skill-claw.md b/tools/skillgen/expected/graphify__skill-claw.md index bad0a0d54..cc00d31fa 100644 --- a/tools/skillgen/expected/graphify__skill-claw.md +++ b/tools/skillgen/expected/graphify__skill-claw.md @@ -27,6 +27,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -478,9 +480,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/tools/skillgen/expected/graphify__skill-codex.md b/tools/skillgen/expected/graphify__skill-codex.md index b9a70f06a..3259bc217 100644 --- a/tools/skillgen/expected/graphify__skill-codex.md +++ b/tools/skillgen/expected/graphify__skill-codex.md @@ -27,6 +27,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -475,9 +477,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/tools/skillgen/expected/graphify__skill-copilot.md b/tools/skillgen/expected/graphify__skill-copilot.md index bad0a0d54..cc00d31fa 100644 --- a/tools/skillgen/expected/graphify__skill-copilot.md +++ b/tools/skillgen/expected/graphify__skill-copilot.md @@ -27,6 +27,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -478,9 +480,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/tools/skillgen/expected/graphify__skill-droid.md b/tools/skillgen/expected/graphify__skill-droid.md index 6c965c679..b0f36e9d1 100644 --- a/tools/skillgen/expected/graphify__skill-droid.md +++ b/tools/skillgen/expected/graphify__skill-droid.md @@ -27,6 +27,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -475,9 +477,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/tools/skillgen/expected/graphify__skill-kilo.md b/tools/skillgen/expected/graphify__skill-kilo.md index 8bc6d5369..0fce87864 100644 --- a/tools/skillgen/expected/graphify__skill-kilo.md +++ b/tools/skillgen/expected/graphify__skill-kilo.md @@ -27,6 +27,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -478,9 +480,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/tools/skillgen/expected/graphify__skill-kiro.md b/tools/skillgen/expected/graphify__skill-kiro.md index 796ad8ca5..fe398f0c9 100644 --- a/tools/skillgen/expected/graphify__skill-kiro.md +++ b/tools/skillgen/expected/graphify__skill-kiro.md @@ -26,6 +26,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -477,9 +479,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/tools/skillgen/expected/graphify__skill-opencode.md b/tools/skillgen/expected/graphify__skill-opencode.md index 6c4f20864..ff5eb0b38 100644 --- a/tools/skillgen/expected/graphify__skill-opencode.md +++ b/tools/skillgen/expected/graphify__skill-opencode.md @@ -27,6 +27,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -470,9 +472,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/tools/skillgen/expected/graphify__skill-pi.md b/tools/skillgen/expected/graphify__skill-pi.md index 796ad8ca5..fe398f0c9 100644 --- a/tools/skillgen/expected/graphify__skill-pi.md +++ b/tools/skillgen/expected/graphify__skill-pi.md @@ -26,6 +26,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -477,9 +479,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/tools/skillgen/expected/graphify__skill-trae.md b/tools/skillgen/expected/graphify__skill-trae.md index 8ba7c66f6..df963642a 100644 --- a/tools/skillgen/expected/graphify__skill-trae.md +++ b/tools/skillgen/expected/graphify__skill-trae.md @@ -27,6 +27,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -476,9 +478,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/tools/skillgen/expected/graphify__skill-vscode.md b/tools/skillgen/expected/graphify__skill-vscode.md index 7be667ca9..4d9736ddc 100644 --- a/tools/skillgen/expected/graphify__skill-vscode.md +++ b/tools/skillgen/expected/graphify__skill-vscode.md @@ -27,6 +27,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -474,9 +476,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/tools/skillgen/expected/graphify__skill-windows.md b/tools/skillgen/expected/graphify__skill-windows.md index a15480dce..d8adc0018 100644 --- a/tools/skillgen/expected/graphify__skill-windows.md +++ b/tools/skillgen/expected/graphify__skill-windows.md @@ -27,6 +27,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -500,9 +502,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/tools/skillgen/expected/graphify__skill.md b/tools/skillgen/expected/graphify__skill.md index 4e9827b13..ec9c5dd88 100644 --- a/tools/skillgen/expected/graphify__skill.md +++ b/tools/skillgen/expected/graphify__skill.md @@ -27,6 +27,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -478,9 +480,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/tools/skillgen/expected/graphify__skills__amp__references__exports.md b/tools/skillgen/expected/graphify__skills__amp__references__exports.md index 3750ff23b..5c357d385 100644 --- a/tools/skillgen/expected/graphify__skills__amp__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__amp__references__exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/tools/skillgen/expected/graphify__skills__claude__references__exports.md b/tools/skillgen/expected/graphify__skills__claude__references__exports.md index 3750ff23b..5c357d385 100644 --- a/tools/skillgen/expected/graphify__skills__claude__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__claude__references__exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/tools/skillgen/expected/graphify__skills__claw__references__exports.md b/tools/skillgen/expected/graphify__skills__claw__references__exports.md index 3750ff23b..5c357d385 100644 --- a/tools/skillgen/expected/graphify__skills__claw__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__claw__references__exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/tools/skillgen/expected/graphify__skills__codex__references__exports.md b/tools/skillgen/expected/graphify__skills__codex__references__exports.md index 3750ff23b..5c357d385 100644 --- a/tools/skillgen/expected/graphify__skills__codex__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__codex__references__exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/tools/skillgen/expected/graphify__skills__copilot__references__exports.md b/tools/skillgen/expected/graphify__skills__copilot__references__exports.md index 3750ff23b..5c357d385 100644 --- a/tools/skillgen/expected/graphify__skills__copilot__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__copilot__references__exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/tools/skillgen/expected/graphify__skills__droid__references__exports.md b/tools/skillgen/expected/graphify__skills__droid__references__exports.md index 3750ff23b..5c357d385 100644 --- a/tools/skillgen/expected/graphify__skills__droid__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__droid__references__exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/tools/skillgen/expected/graphify__skills__kilo__references__exports.md b/tools/skillgen/expected/graphify__skills__kilo__references__exports.md index 3750ff23b..5c357d385 100644 --- a/tools/skillgen/expected/graphify__skills__kilo__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__kilo__references__exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/tools/skillgen/expected/graphify__skills__kiro__references__exports.md b/tools/skillgen/expected/graphify__skills__kiro__references__exports.md index 3750ff23b..5c357d385 100644 --- a/tools/skillgen/expected/graphify__skills__kiro__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__kiro__references__exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/tools/skillgen/expected/graphify__skills__opencode__references__exports.md b/tools/skillgen/expected/graphify__skills__opencode__references__exports.md index 3750ff23b..5c357d385 100644 --- a/tools/skillgen/expected/graphify__skills__opencode__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__opencode__references__exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/tools/skillgen/expected/graphify__skills__pi__references__exports.md b/tools/skillgen/expected/graphify__skills__pi__references__exports.md index 3750ff23b..5c357d385 100644 --- a/tools/skillgen/expected/graphify__skills__pi__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__pi__references__exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/tools/skillgen/expected/graphify__skills__trae__references__exports.md b/tools/skillgen/expected/graphify__skills__trae__references__exports.md index 3750ff23b..5c357d385 100644 --- a/tools/skillgen/expected/graphify__skills__trae__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__trae__references__exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/tools/skillgen/expected/graphify__skills__vscode__references__exports.md b/tools/skillgen/expected/graphify__skills__vscode__references__exports.md index 3750ff23b..5c357d385 100644 --- a/tools/skillgen/expected/graphify__skills__vscode__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__vscode__references__exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/tools/skillgen/expected/graphify__skills__windows__references__exports.md b/tools/skillgen/expected/graphify__skills__windows__references__exports.md index 3750ff23b..5c357d385 100644 --- a/tools/skillgen/expected/graphify__skills__windows__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__windows__references__exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash diff --git a/tools/skillgen/fragments/core/core.md b/tools/skillgen/fragments/core/core.md index 4a56635e8..a0c416c51 100644 --- a/tools/skillgen/fragments/core/core.md +++ b/tools/skillgen/fragments/core/core.md @@ -23,6 +23,8 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify --graphml # export graph.graphml (Gephi, yEd) /graphify --neo4j # generate graphify-out/cypher.txt for Neo4j /graphify --neo4j-push bolt://localhost:7687 # push directly to Neo4j +/graphify --falkordb # generate graphify-out/cypher.txt for FalkorDB +/graphify --falkordb-push falkordb://localhost:6379 # push directly to FalkorDB /graphify --mcp # start MCP stdio server for agent access /graphify --watch # watch folder, auto-rebuild on code changes (no LLM needed) /graphify --wiki # build agent-crawlable wiki (index.md + one article per community) @@ -412,9 +414,9 @@ graphify export html # auto-aggregates to community view if graph > 5000 nodes # or: graphify export html --no-viz ``` -### Steps 6b-8 - Wiki, Neo4j, SVG, GraphML, MCP, benchmark (only on their flags) +### Steps 6b-8 - Wiki, Neo4j, FalkorDB, SVG, GraphML, MCP, benchmark (only on their flags) -These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. +These run only when their flag is present (`--wiki`, `--neo4j`/`--neo4j-push`, `--falkordb`/`--falkordb-push`, `--svg`, `--graphml`, `--mcp`) or, for the token-reduction benchmark, when `total_words` exceeds 5,000. A default run with no export flags skips all of them. See `references/exports.md` for each one. Run any `--wiki` export before Step 9 cleanup so `.graphify_labels.json` is still available. --- diff --git a/tools/skillgen/fragments/references/shared/exports.md b/tools/skillgen/fragments/references/shared/exports.md index 3750ff23b..5c357d385 100644 --- a/tools/skillgen/fragments/references/shared/exports.md +++ b/tools/skillgen/fragments/references/shared/exports.md @@ -1,6 +1,6 @@ # graphify reference: extra exports and benchmark -Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. +Load this when the user passed one of the export flags (`--wiki`, `--neo4j`, `--neo4j-push`, `--falkordb`, `--falkordb-push`, `--svg`, `--graphml`, `--mcp`), or when the corpus is large enough for the token-reduction benchmark. Each step runs only for its own flag. ### Step 6b - Wiki (only if --wiki flag) @@ -28,6 +28,22 @@ graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSW Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) + +**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): + +```bash +graphify export falkordb +``` + +**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: + +```bash +graphify export falkordb --push falkordb://localhost:6379 +``` + +Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. + ### Step 7b - SVG export (only if --svg flag) ```bash From 12615226e41b8f9a4343031fce7fee3b18ed31e0 Mon Sep 17 00:00:00 2001 From: Gal Shubeli Date: Mon, 8 Jun 2026 12:59:26 +0300 Subject: [PATCH 3/4] fix: correct FalkorDB cypher.txt import guidance The no-push 'graphify export falkordb' path advertised 'redis-cli -x GRAPH.QUERY graphify < cypher.txt', but FalkorDB rejects that with 'query with more than one statement is not supported' - cypher.txt is a multi-statement Neo4j script. The individual statements ARE valid OpenCypher (verified by loading them one at a time), only bulk script import is unsupported. Message + skill docs now say so and point to --push (the verified load path). --- graphify/__main__.py | 6 ++++-- graphify/skills/amp/references/exports.md | 2 +- graphify/skills/claude/references/exports.md | 2 +- graphify/skills/claw/references/exports.md | 2 +- graphify/skills/codex/references/exports.md | 2 +- graphify/skills/copilot/references/exports.md | 2 +- graphify/skills/droid/references/exports.md | 2 +- graphify/skills/kilo/references/exports.md | 2 +- graphify/skills/kiro/references/exports.md | 2 +- graphify/skills/opencode/references/exports.md | 2 +- graphify/skills/pi/references/exports.md | 2 +- graphify/skills/trae/references/exports.md | 2 +- graphify/skills/vscode/references/exports.md | 2 +- graphify/skills/windows/references/exports.md | 2 +- .../expected/graphify__skills__amp__references__exports.md | 2 +- .../graphify__skills__claude__references__exports.md | 2 +- .../expected/graphify__skills__claw__references__exports.md | 2 +- .../graphify__skills__codex__references__exports.md | 2 +- .../graphify__skills__copilot__references__exports.md | 2 +- .../graphify__skills__droid__references__exports.md | 2 +- .../expected/graphify__skills__kilo__references__exports.md | 2 +- .../expected/graphify__skills__kiro__references__exports.md | 2 +- .../graphify__skills__opencode__references__exports.md | 2 +- .../expected/graphify__skills__pi__references__exports.md | 2 +- .../expected/graphify__skills__trae__references__exports.md | 2 +- .../graphify__skills__vscode__references__exports.md | 2 +- .../graphify__skills__windows__references__exports.md | 2 +- tools/skillgen/fragments/references/shared/exports.md | 2 +- 28 files changed, 31 insertions(+), 29 deletions(-) diff --git a/graphify/__main__.py b/graphify/__main__.py index bbf88b3c1..cef0da4c1 100644 --- a/graphify/__main__.py +++ b/graphify/__main__.py @@ -3639,8 +3639,10 @@ def _load_graph(p: str): else: from graphify.export import to_cypher as _to_cypher _to_cypher(G, str(out_dir / "cypher.txt")) - print(f"cypher.txt written - FalkorDB is OpenCypher-compatible; " - f"import with: redis-cli -x GRAPH.QUERY graphify < {out_dir}/cypher.txt") + print(f"cypher.txt written ({out_dir}/cypher.txt) - statements are OpenCypher. " + f"FalkorDB's GRAPH.QUERY runs one statement at a time (no bulk script " + f"import), so load a graph with: graphify export falkordb --push " + f"falkordb://localhost:6379") elif cmd == "benchmark": from graphify.benchmark import run_benchmark, print_benchmark diff --git a/graphify/skills/amp/references/exports.md b/graphify/skills/amp/references/exports.md index 5c357d385..1c5d8c09a 100644 --- a/graphify/skills/amp/references/exports.md +++ b/graphify/skills/amp/references/exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/graphify/skills/claude/references/exports.md b/graphify/skills/claude/references/exports.md index 5c357d385..1c5d8c09a 100644 --- a/graphify/skills/claude/references/exports.md +++ b/graphify/skills/claude/references/exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/graphify/skills/claw/references/exports.md b/graphify/skills/claw/references/exports.md index 5c357d385..1c5d8c09a 100644 --- a/graphify/skills/claw/references/exports.md +++ b/graphify/skills/claw/references/exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/graphify/skills/codex/references/exports.md b/graphify/skills/codex/references/exports.md index 5c357d385..1c5d8c09a 100644 --- a/graphify/skills/codex/references/exports.md +++ b/graphify/skills/codex/references/exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/graphify/skills/copilot/references/exports.md b/graphify/skills/copilot/references/exports.md index 5c357d385..1c5d8c09a 100644 --- a/graphify/skills/copilot/references/exports.md +++ b/graphify/skills/copilot/references/exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/graphify/skills/droid/references/exports.md b/graphify/skills/droid/references/exports.md index 5c357d385..1c5d8c09a 100644 --- a/graphify/skills/droid/references/exports.md +++ b/graphify/skills/droid/references/exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/graphify/skills/kilo/references/exports.md b/graphify/skills/kilo/references/exports.md index 5c357d385..1c5d8c09a 100644 --- a/graphify/skills/kilo/references/exports.md +++ b/graphify/skills/kilo/references/exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/graphify/skills/kiro/references/exports.md b/graphify/skills/kiro/references/exports.md index 5c357d385..1c5d8c09a 100644 --- a/graphify/skills/kiro/references/exports.md +++ b/graphify/skills/kiro/references/exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/graphify/skills/opencode/references/exports.md b/graphify/skills/opencode/references/exports.md index 5c357d385..1c5d8c09a 100644 --- a/graphify/skills/opencode/references/exports.md +++ b/graphify/skills/opencode/references/exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/graphify/skills/pi/references/exports.md b/graphify/skills/pi/references/exports.md index 5c357d385..1c5d8c09a 100644 --- a/graphify/skills/pi/references/exports.md +++ b/graphify/skills/pi/references/exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/graphify/skills/trae/references/exports.md b/graphify/skills/trae/references/exports.md index 5c357d385..1c5d8c09a 100644 --- a/graphify/skills/trae/references/exports.md +++ b/graphify/skills/trae/references/exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/graphify/skills/vscode/references/exports.md b/graphify/skills/vscode/references/exports.md index 5c357d385..1c5d8c09a 100644 --- a/graphify/skills/vscode/references/exports.md +++ b/graphify/skills/vscode/references/exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/graphify/skills/windows/references/exports.md b/graphify/skills/windows/references/exports.md index 5c357d385..1c5d8c09a 100644 --- a/graphify/skills/windows/references/exports.md +++ b/graphify/skills/windows/references/exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/tools/skillgen/expected/graphify__skills__amp__references__exports.md b/tools/skillgen/expected/graphify__skills__amp__references__exports.md index 5c357d385..1c5d8c09a 100644 --- a/tools/skillgen/expected/graphify__skills__amp__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__amp__references__exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/tools/skillgen/expected/graphify__skills__claude__references__exports.md b/tools/skillgen/expected/graphify__skills__claude__references__exports.md index 5c357d385..1c5d8c09a 100644 --- a/tools/skillgen/expected/graphify__skills__claude__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__claude__references__exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/tools/skillgen/expected/graphify__skills__claw__references__exports.md b/tools/skillgen/expected/graphify__skills__claw__references__exports.md index 5c357d385..1c5d8c09a 100644 --- a/tools/skillgen/expected/graphify__skills__claw__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__claw__references__exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/tools/skillgen/expected/graphify__skills__codex__references__exports.md b/tools/skillgen/expected/graphify__skills__codex__references__exports.md index 5c357d385..1c5d8c09a 100644 --- a/tools/skillgen/expected/graphify__skills__codex__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__codex__references__exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/tools/skillgen/expected/graphify__skills__copilot__references__exports.md b/tools/skillgen/expected/graphify__skills__copilot__references__exports.md index 5c357d385..1c5d8c09a 100644 --- a/tools/skillgen/expected/graphify__skills__copilot__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__copilot__references__exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/tools/skillgen/expected/graphify__skills__droid__references__exports.md b/tools/skillgen/expected/graphify__skills__droid__references__exports.md index 5c357d385..1c5d8c09a 100644 --- a/tools/skillgen/expected/graphify__skills__droid__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__droid__references__exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/tools/skillgen/expected/graphify__skills__kilo__references__exports.md b/tools/skillgen/expected/graphify__skills__kilo__references__exports.md index 5c357d385..1c5d8c09a 100644 --- a/tools/skillgen/expected/graphify__skills__kilo__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__kilo__references__exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/tools/skillgen/expected/graphify__skills__kiro__references__exports.md b/tools/skillgen/expected/graphify__skills__kiro__references__exports.md index 5c357d385..1c5d8c09a 100644 --- a/tools/skillgen/expected/graphify__skills__kiro__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__kiro__references__exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/tools/skillgen/expected/graphify__skills__opencode__references__exports.md b/tools/skillgen/expected/graphify__skills__opencode__references__exports.md index 5c357d385..1c5d8c09a 100644 --- a/tools/skillgen/expected/graphify__skills__opencode__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__opencode__references__exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/tools/skillgen/expected/graphify__skills__pi__references__exports.md b/tools/skillgen/expected/graphify__skills__pi__references__exports.md index 5c357d385..1c5d8c09a 100644 --- a/tools/skillgen/expected/graphify__skills__pi__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__pi__references__exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/tools/skillgen/expected/graphify__skills__trae__references__exports.md b/tools/skillgen/expected/graphify__skills__trae__references__exports.md index 5c357d385..1c5d8c09a 100644 --- a/tools/skillgen/expected/graphify__skills__trae__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__trae__references__exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/tools/skillgen/expected/graphify__skills__vscode__references__exports.md b/tools/skillgen/expected/graphify__skills__vscode__references__exports.md index 5c357d385..1c5d8c09a 100644 --- a/tools/skillgen/expected/graphify__skills__vscode__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__vscode__references__exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/tools/skillgen/expected/graphify__skills__windows__references__exports.md b/tools/skillgen/expected/graphify__skills__windows__references__exports.md index 5c357d385..1c5d8c09a 100644 --- a/tools/skillgen/expected/graphify__skills__windows__references__exports.md +++ b/tools/skillgen/expected/graphify__skills__windows__references__exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb diff --git a/tools/skillgen/fragments/references/shared/exports.md b/tools/skillgen/fragments/references/shared/exports.md index 5c357d385..1c5d8c09a 100644 --- a/tools/skillgen/fragments/references/shared/exports.md +++ b/tools/skillgen/fragments/references/shared/exports.md @@ -30,7 +30,7 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) -**If `--falkordb`** - generate a Cypher file (FalkorDB is OpenCypher-compatible, so the same `cypher.txt` imports cleanly): +**If `--falkordb`** - generate a Cypher file. The statements are OpenCypher, but FalkorDB's `GRAPH.QUERY` runs one statement at a time (no bulk script import like Neo4j's `cypher-shell`), so prefer `--falkordb-push` to load a graph. Use this only when you want the portable `cypher.txt` artifact: ```bash graphify export falkordb From 418604f32a45540f52754368c53b1efe2dd5b371 Mon Sep 17 00:00:00 2001 From: Gal Shubeli Date: Mon, 8 Jun 2026 13:05:24 +0300 Subject: [PATCH 4/4] refactor: rename neo4j_* push vars to push_* (shared by neo4j + falkordb) The --push/--user/--password export flags feed both the neo4j and falkordb dispatch branches, so the neo4j_ prefix was misleading - a neo4j_password that reads FALKORDB_PASSWORD made no sense. Renamed to push_uri/push_user/ push_password, and the password env lookup now reads the backend-specific var (FALKORDB_PASSWORD for falkordb, NEO4J_PASSWORD otherwise) instead of OR-ing both. --- graphify/__main__.py | 40 ++++++++++++++++++++++------------------ 1 file changed, 22 insertions(+), 18 deletions(-) diff --git a/graphify/__main__.py b/graphify/__main__.py index cef0da4c1..7e4102a5c 100644 --- a/graphify/__main__.py +++ b/graphify/__main__.py @@ -3404,14 +3404,18 @@ def _load_graph(p: str): node_limit = 5000 no_viz = False obsidian_dir = Path(_GRAPHIFY_OUT) / "obsidian" - neo4j_uri: str | None = None - neo4j_user = "neo4j" - # F-031: prefer the NEO4J_PASSWORD env var so the password never - # appears on argv (visible in `ps` output / shell history). The - # explicit --password flag still overrides it for compatibility. - neo4j_password: str | None = ( - os.environ.get("NEO4J_PASSWORD") or os.environ.get("FALKORDB_PASSWORD") or None - ) + # Shared push-connection settings for the graph-database sinks (neo4j, + # falkordb), parsed from the generic --push/--user/--password flags below. + push_uri: str | None = None + push_user = "neo4j" # Neo4j default user; FalkorDB auth is optional and ignores it + # F-031: prefer an env var so the password never appears on argv (visible + # in `ps` output / shell history). The explicit --password flag still + # overrides it. Each sink reads its own var: FALKORDB_PASSWORD for falkordb, + # NEO4J_PASSWORD otherwise. + push_password: str | None = ( + os.environ.get("FALKORDB_PASSWORD") if subcmd == "falkordb" + else os.environ.get("NEO4J_PASSWORD") + ) or None i = 0 while i < len(args): a = args[i] @@ -3462,11 +3466,11 @@ def _load_graph(p: str): elif a == "--dir" and i + 1 < len(args): obsidian_dir = Path(args[i + 1]); i += 2 elif a == "--push" and i + 1 < len(args): - neo4j_uri = args[i + 1]; i += 2 + push_uri = args[i + 1]; i += 2 elif a == "--user" and i + 1 < len(args): - neo4j_user = args[i + 1]; i += 2 + push_user = args[i + 1]; i += 2 elif a == "--password" and i + 1 < len(args): - neo4j_password = args[i + 1]; i += 2 + push_password = args[i + 1]; i += 2 elif subcmd == "callflow-html" and not a.startswith("-") and not graph_path_explicit: candidate = Path(a) if candidate.name == "graph.json" or candidate.suffix.lower() == ".json": @@ -3617,13 +3621,13 @@ def _load_graph(p: str): print(f"graph.graphml written - open in Gephi, yEd, or any GraphML tool") elif subcmd == "neo4j": - if neo4j_uri: + if push_uri: from graphify.export import push_to_neo4j as _push - if neo4j_password is None: + if push_password is None: print("error: --password required for --push", file=sys.stderr) sys.exit(1) - result = _push(G, uri=neo4j_uri, user=neo4j_user, - password=neo4j_password, communities=communities) + result = _push(G, uri=push_uri, user=push_user, + password=push_password, communities=communities) print(f"Pushed to Neo4j: {result['nodes']} nodes, {result['edges']} edges") else: from graphify.export import to_cypher as _to_cypher @@ -3631,10 +3635,10 @@ def _load_graph(p: str): print(f"cypher.txt written - import with: cypher-shell < {out_dir}/cypher.txt") elif subcmd == "falkordb": - if neo4j_uri: + if push_uri: from graphify.export import push_to_falkordb as _push - result = _push(G, uri=neo4j_uri, user=neo4j_user, - password=neo4j_password, communities=communities) + result = _push(G, uri=push_uri, user=push_user, + password=push_password, communities=communities) print(f"Pushed to FalkorDB: {result['nodes']} nodes, {result['edges']} edges") else: from graphify.export import to_cypher as _to_cypher