diff --git a/.github/workflows/pypi-publish.yml b/.github/workflows/pypi-publish.yml
index 6fff883..1625395 100644
--- a/.github/workflows/pypi-publish.yml
+++ b/.github/workflows/pypi-publish.yml
@@ -5,7 +5,8 @@ on:
     tags: ["v*.*.*"]
 
 jobs:
-  publish:
+  publish-server:
+    name: Publish falkordb-code-graph
     runs-on: ubuntu-latest
     environment: pypi
     permissions:
@@ -22,3 +23,24 @@ jobs:
 
       - name: Publish to PyPI
         uses: pypa/gh-action-pypi-publish@release/v1
+
+  publish-cli:
+    name: Publish falkordb-cgraph
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Build CLI package
+        run: cd cli && uv build
+
+      - name: Publish CLI to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: cli/dist/
diff --git a/AGENTS.md b/AGENTS.md
index 1b2679b..519b563 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -21,7 +21,7 @@ Knowledge graph visualization tool for codebases. Python FastAPI backend + React
 
 ```text
 api/                  # Python backend
-  cli.py              # cgraph CLI tool (typer)
+  cli.py              # cgraph CLI tool (typer) — full version used during dev
   index.py            # FastAPI app, routes, auth, SPA serving
   graph.py            # FalkorDB graph operations (sync + async)
   llm.py              # GraphRAG + LiteLLM chat
@@ -32,6 +32,10 @@ api/                  # Python backend
   analyzers/          # Language-specific code analyzers
   entities/           # Graph entity models
   git_utils/          # Git history graph construction
+cli/                  # Lightweight CLI package (falkordb-cgraph)
+  pyproject.toml      # Minimal deps: falkordb + typer only
+  cgraph/
+    main.py           # Standalone CLI commands (list, search, neighbors, paths, info, ensure-db)
 app/                  # React frontend (Vite)
   src/components/     # React components (ForceGraph, chat, code-graph, etc.)
   src/lib/            # Utilities
@@ -136,16 +140,26 @@ Key variables (see `.env.template` for full list):
 
 ## CLI (`cgraph`)
 
-Typer-based CLI wrapping the sync `Graph` and `Project` classes. Outputs JSON to stdout, status to stderr. Entry point: `api/cli.py`.
+Two packages provide the `cgraph` command:
 
-Install: `pipx install falkordb-code-graph` or `pip install falkordb-code-graph`
+**Lightweight CLI** (`falkordb-cgraph` — the recommended install for end users):
 
-For development: `make install-cli` or `uv pip install -e .`
+Install: `pipx install falkordb-cgraph`
+
+For development: `make install-cli` (installs from `cli/`)
+
+Provides query commands only (`list`, `search`, `neighbors`, `paths`, `info`, `ensure-db`). The `index` and `index-repo` commands print a helpful message directing users to install `falkordb-code-graph`.
+
+**Full server package** (`falkordb-code-graph` — for development/Docker):
+
+Install: `pip install falkordb-code-graph` or `uv sync`
+
+Also provides `cgraph` via `api/cli.py` and includes all indexing commands.
 
 ```bash
 cgraph ensure-db                          # Start FalkorDB if not running
-cgraph index . --ignore node_modules      # Index local folder
-cgraph index-repo <url>                   # Clone + index a repo
+cgraph index . --ignore node_modules      # Index local folder (full package only)
+cgraph index-repo <url>                   # Clone + index a repo (full package only)
 cgraph list                               # List indexed repos
 cgraph search <prefix> [--repo <name>]    # Full-text prefix search
 cgraph neighbors <id>... [--repo <name>] [--rel <type>] [--label <label>]  # Connected entities
diff --git a/Makefile b/Makefile
index e3ff460..1bfe08a 100644
--- a/Makefile
+++ b/Makefile
@@ -10,8 +10,8 @@ install: ## Install all dependencies (backend + frontend)
 	uv sync --all-extras
 	npm install --prefix ./app
 
-install-cli: ## Install cgraph CLI entry point
-	uv pip install -e .
+install-cli: ## Install lightweight cgraph CLI (falkordb-cgraph) entry point
+	pip install -e ./cli
 
 build-dev: ## Build frontend for development
 	npm --prefix ./app run build:dev
diff --git a/README.md b/README.md
index e2e54bb..edc2fef 100644
--- a/README.md
+++ b/README.md
@@ -26,12 +26,16 @@ code-graph/
 │   ├── project.py        # Repository cloning and analysis orchestration
 │   ├── info.py           # Repository metadata stored in Redis/FalkorDB
 │   ├── prompts.py        # LLM system and prompt templates
-│   ├── cli.py            # cgraph CLI tool (typer)
+│   ├── cli.py            # cgraph CLI tool (full version, dev use)
 │   ├── auto_complete.py  # Prefix search helper
 │   ├── analyzers/        # Source analyzers (Python, Java, C#)
 │   ├── entities/         # Graph/entity models
 │   ├── git_utils/        # Git history graph utilities
 │   └── code_coverage/    # Coverage utilities
+├── cli/                  # Lightweight CLI package (falkordb-cgraph)
+│   ├── pyproject.toml    # Minimal deps: falkordb + typer only
+│   └── cgraph/
+│       └── main.py       # Standalone CLI (list, search, neighbors, paths, info, ensure-db)
 ├── app/                  # React frontend (Vite)
 │   ├── src/              # Frontend source code
 │   ├── public/           # Static assets
@@ -45,7 +49,7 @@ code-graph/
 ├── docker-compose.yml    # Local FalkorDB + app stack
 ├── Makefile              # Common dev/build/test commands
 ├── start.sh              # Container entrypoint
-├── pyproject.toml        # Python package and dependency config
+├── pyproject.toml        # Python server package (falkordb-code-graph) with all deps
 └── .env.template         # Example environment variables
 ```
 
@@ -162,23 +166,31 @@ make clean         # Remove build/test artifacts
 
 ## CLI Tool (`cgraph`)
 
-CodeGraph includes a CLI tool for indexing codebases and querying the knowledge graph directly from the terminal. All output is JSON (to stdout), with status messages on stderr.
+CodeGraph includes a CLI tool for querying the knowledge graph directly from the terminal. All output is JSON (to stdout), with status messages on stderr.
 
 ### Install
 
+**Lightweight CLI** (recommended for end users — fast install, only `falkordb` + `typer`):
+
 ```bash
-# Install from PyPI (recommended for end users)
-pipx install falkordb-code-graph
+# Install from PyPI (recommended)
+pipx install falkordb-cgraph
 
 # Or with pip
+pip install falkordb-cgraph
+```
+
+**Full server package** (includes indexing commands, web server, all heavy deps):
+
+```bash
 pip install falkordb-code-graph
 ```
 
 For development (from a local clone):
 
 ```bash
-make install-cli
-# or
+make install-cli   # installs falkordb-cgraph from cli/
+# or for full server package:
 uv pip install -e .
 ```
 
@@ -188,10 +200,10 @@ uv pip install -e .
 # Ensure FalkorDB is running (auto-starts a Docker container if needed)
 cgraph ensure-db
 
-# Index the current project
+# Index the current project (requires falkordb-code-graph)
 cgraph index . --ignore node_modules --ignore .git --ignore venv --ignore __pycache__
 
-# Index a remote repository
+# Index a remote repository (requires falkordb-code-graph)
 cgraph index-repo https://github.com/user/repo --ignore node_modules
 
 # List indexed repos
diff --git a/cli/README.md b/cli/README.md
new file mode 100644
index 0000000..593cd48
--- /dev/null
+++ b/cli/README.md
@@ -0,0 +1,54 @@
+# falkordb-cgraph
+
+Lightweight CLI for querying [FalkorDB](https://falkordb.com) code-graph knowledge graphs.
+
+## Installation
+
+```bash
+pipx install falkordb-cgraph
+```
+
+This installs only `falkordb` and `typer` — no heavy server-side dependencies.
+
+## Usage
+
+```bash
+cgraph --help
+
+# Ensure FalkorDB is running (starts a Docker container if needed)
+cgraph ensure-db
+
+# List all indexed repositories
+cgraph list
+
+# Search for entities by prefix
+cgraph search <prefix> [--repo <name>]
+
+# Get neighboring entities
+cgraph neighbors <id>... [--repo <name>] [--rel <type>] [--label <label>]
+
+# Find call-chain paths between two nodes
+cgraph paths <src-id> <dest-id> [--repo <name>]
+
+# Show repository statistics and metadata
+cgraph info [--repo <name>]
+```
+
+`--repo` defaults to the current directory name.
+
+## Indexing
+
+The `index` and `index-repo` commands require the full server package:
+
+```bash
+pip install falkordb-code-graph
+```
+
+## Environment variables
+
+| Variable | Default | Purpose |
+|----------|---------|---------|
+| `FALKORDB_HOST` | `localhost` | FalkorDB host |
+| `FALKORDB_PORT` | `6379` | FalkorDB port |
+| `FALKORDB_USERNAME` | — | FalkorDB username (optional) |
+| `FALKORDB_PASSWORD` | — | FalkorDB password (optional) |
diff --git a/cli/cgraph/__init__.py b/cli/cgraph/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/cli/cgraph/main.py b/cli/cgraph/main.py
new file mode 100644
index 0000000..b99405f
--- /dev/null
+++ b/cli/cgraph/main.py
@@ -0,0 +1,421 @@
+"""Code Graph CLI — query code knowledge graphs stored in FalkorDB.
+
+Machine-readable JSON goes to stdout; human status goes to stderr.
+
+This is the lightweight CLI package (falkordb-cgraph). It only depends on
+``falkordb`` and ``typer`` so ``pipx install falkordb-cgraph`` is fast.
+
+For indexing commands (``index`` / ``index-repo``) install the full server
+package instead::
+
+    pip install falkordb-code-graph
+"""
+
+import json
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import List, Optional
+
+import typer
+from falkordb import FalkorDB, Node, Edge
+
+app = typer.Typer(
+    help="Query FalkorDB code-graph knowledge graphs.",
+    no_args_is_help=True,
+)
+
+_LOCAL_HOSTS = {"localhost", "127.0.0.1", "::1"}
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _stderr(msg: str) -> None:
+    print(msg, file=sys.stderr)
+
+
+def _json_out(data: object) -> None:
+    print(json.dumps(data, default=str))
+
+
+def _json_error(message: str, code: int = 1) -> None:
+    """Emit a JSON error to stdout and exit."""
+    _json_out({"status": "error", "message": message})
+    raise typer.Exit(code=code)
+
+
+def _default_repo(repo: Optional[str]) -> str:
+    return repo if repo else Path.cwd().name
+
+
+def _db() -> FalkorDB:
+    return FalkorDB(
+        host=os.getenv("FALKORDB_HOST", "localhost"),
+        port=int(os.getenv("FALKORDB_PORT", "6379")),
+        username=os.getenv("FALKORDB_USERNAME", None),
+        password=os.getenv("FALKORDB_PASSWORD", None),
+    )
+
+
+def _check_connection(host: str, port: int) -> bool:
+    """Check if FalkorDB/Redis is reachable via PING.
+
+    ``redis`` is a direct dependency of ``falkordb`` and is always available.
+    """
+    import redis
+
+    r: Optional[redis.Redis] = None
+    try:
+        r = redis.Redis(host=host, port=port, socket_connect_timeout=2)
+        r.ping()
+        return True
+    except Exception:
+        return False
+    finally:
+        if r is not None:
+            r.close()
+
+
+def _encode_node(n: Node) -> dict:
+    if "Searchable" in n.labels:
+        n.labels.remove("Searchable")
+    return vars(n)
+
+
+def _encode_edge(e: Edge) -> dict:
+    return vars(e)
+
+
+def _get_repos() -> list[str]:
+    db = _db()
+    graphs = db.list_graphs()
+    return [g for g in graphs if not (g.endswith("_git") or g.endswith("_schema"))]
+
+
+def _get_repo_info(repo_name: str) -> Optional[dict]:
+    import redis as _redis
+
+    r = _redis.Redis(
+        host=os.getenv("FALKORDB_HOST", "localhost"),
+        port=int(os.getenv("FALKORDB_PORT", "6379")),
+        username=os.getenv("FALKORDB_USERNAME"),
+        password=os.getenv("FALKORDB_PASSWORD"),
+        decode_responses=True,
+    )
+    try:
+        key = f"{{{repo_name}}}_info"
+        info = r.hgetall(key)
+        return info if info else None
+    finally:
+        r.close()
+
+
+# ---------------------------------------------------------------------------
+# ensure-db
+# ---------------------------------------------------------------------------
+
+@app.command("ensure-db")
+def ensure_db() -> None:
+    """Ensure FalkorDB is running, auto-starting a Docker container if needed."""
+
+    host = os.getenv("FALKORDB_HOST", "localhost")
+    try:
+        port = int(os.getenv("FALKORDB_PORT", "6379"))
+    except ValueError:
+        _json_error(f"Invalid FALKORDB_PORT: {os.getenv('FALKORDB_PORT')!r} — must be an integer")
+    if not 1 <= port <= 65535:
+        _json_error(f"FALKORDB_PORT must be between 1 and 65535, got {port}")
+
+    if _check_connection(host, port):
+        _stderr(f"FalkorDB already running on {host}:{port}")
+        _json_out({"status": "ok", "host": host, "port": port})
+        return
+
+    if host not in _LOCAL_HOSTS:
+        _json_error(
+            f"FalkorDB not reachable on {host}:{port} "
+            "and auto-start is only supported for localhost"
+        )
+
+    _stderr(f"FalkorDB not reachable on {host}:{port}, starting Docker container…")
+
+    try:
+        inspect = subprocess.run(
+            [
+                "docker",
+                "inspect",
+                "--format",
+                "{{.State.Running}}",
+                "falkordb-cgraph",
+            ],
+            capture_output=True,
+            text=True,
+        )
+
+        if inspect.returncode == 0:
+            port_inspect = subprocess.run(
+                [
+                    "docker",
+                    "inspect",
+                    "--format",
+                    '{{(index (index .NetworkSettings.Ports "6379/tcp") 0).HostPort}}',
+                    "falkordb-cgraph",
+                ],
+                capture_output=True,
+                text=True,
+            )
+            existing_port = port_inspect.stdout.strip() if port_inspect.returncode == 0 else None
+            if existing_port and existing_port != str(port):
+                _json_error(
+                    f"Existing falkordb-cgraph container is bound to port {existing_port}, "
+                    f"but FALKORDB_PORT is {port}. Remove the container and retry."
+                )
+
+            if inspect.stdout.strip() == "false":
+                subprocess.run(
+                    ["docker", "start", "falkordb-cgraph"],
+                    check=True,
+                    capture_output=True,
+                )
+                _stderr("Started existing falkordb-cgraph container")
+        else:
+            subprocess.run(
+                [
+                    "docker",
+                    "run",
+                    "-d",
+                    "--name",
+                    "falkordb-cgraph",
+                    "-p",
+                    f"{port}:6379",
+                    "falkordb/falkordb:latest",
+                ],
+                check=True,
+                capture_output=True,
+            )
+            _stderr("Created and started falkordb-cgraph container")
+    except FileNotFoundError:
+        _json_error("Docker is not installed or not on PATH")
+    except subprocess.CalledProcessError as e:
+        _json_error(f"Docker command failed: {e.stderr.strip() if e.stderr else e}")
+
+    for _ in range(30):
+        if _check_connection(host, port):
+            _stderr("FalkorDB is ready")
+            _json_out({"status": "ok", "host": host, "port": port})
+            return
+        time.sleep(1)
+
+    _stderr("Timed out waiting for FalkorDB to become ready")
+    _json_error("timeout")
+
+
+# ---------------------------------------------------------------------------
+# index / index-repo  (stub — requires the full falkordb-code-graph package)
+# ---------------------------------------------------------------------------
+
+@app.command()
+def index(
+    path: str = typer.Argument(".", help="Local folder to index"),
+    ignore: Optional[List[str]] = typer.Option(
+        None, "--ignore", help="Directories to ignore (repeatable)"
+    ),
+    repo: Optional[str] = typer.Option(
+        None, "--repo", help="Graph name (defaults to folder name)"
+    ),
+) -> None:
+    """Index a local folder into the knowledge graph.
+
+    Requires the full server package. Install it with:
+    pip install falkordb-code-graph
+    """
+    _json_error(
+        "The 'index' command requires the full falkordb-code-graph package. "
+        "Install it with: pip install falkordb-code-graph"
+    )
+
+
+@app.command("index-repo")
+def index_repo(
+    url: str = typer.Argument(..., help="Git repository URL to clone and index"),
+    ignore: Optional[List[str]] = typer.Option(
+        None, "--ignore", help="Directories to ignore (repeatable)"
+    ),
+) -> None:
+    """Clone a git repository and index it into the knowledge graph.
+
+    Requires the full server package. Install it with:
+    pip install falkordb-code-graph
+    """
+    _json_error(
+        "The 'index-repo' command requires the full falkordb-code-graph package. "
+        "Install it with: pip install falkordb-code-graph"
+    )
+
+
+# ---------------------------------------------------------------------------
+# list
+# ---------------------------------------------------------------------------
+
+@app.command("list")
+def list_repos() -> None:
+    """List all indexed repositories."""
+    try:
+        repos = _get_repos()
+    except Exception as e:
+        _json_error(str(e))
+
+    _json_out({"repos": repos})
+
+
+# ---------------------------------------------------------------------------
+# search
+# ---------------------------------------------------------------------------
+
+@app.command()
+def search(
+    query: str = typer.Argument(..., help="Prefix to search for"),
+    repo: Optional[str] = typer.Option(
+        None, "--repo", help="Repository name (defaults to CWD name)"
+    ),
+) -> None:
+    """Search for entities by prefix (full-text search)."""
+    name = _default_repo(repo)
+    try:
+        db = _db()
+        g = db.select_graph(name)
+        search_prefix = f"{query}*"
+        cypher = """
+            CALL db.idx.fulltext.queryNodes('Searchable', $prefix)
+            YIELD node
+            WITH node
+            RETURN node
+            LIMIT 10
+        """
+        result_set = g.query(cypher, {"prefix": search_prefix}).result_set
+        results = [_encode_node(row[0]) for row in result_set]
+    except Exception as e:
+        _json_error(str(e))
+
+    _json_out({"repo": name, "results": results})
+
+
+# ---------------------------------------------------------------------------
+# neighbors
+# ---------------------------------------------------------------------------
+
+@app.command()
+def neighbors(
+    node_ids: List[int] = typer.Argument(..., help="Node IDs to query"),
+    repo: Optional[str] = typer.Option(
+        None, "--repo", help="Repository name (defaults to CWD name)"
+    ),
+    rel: Optional[str] = typer.Option(
+        None, "--rel", help="Filter by relationship type (e.g. CALLS, DEFINES)"
+    ),
+    label: Optional[str] = typer.Option(
+        None, "--label", help="Filter by destination label (e.g. Function, Class)"
+    ),
+) -> None:
+    """Get neighboring entities of the given node(s)."""
+    name = _default_repo(repo)
+    try:
+        db = _db()
+        g = db.select_graph(name)
+
+        rel_query = f":{rel}" if rel else ""
+        lbl_query = f":{label}" if label else ""
+        cypher = f"""
+            MATCH (n)-[e{rel_query}]->(dest{lbl_query})
+            WHERE ID(n) IN $node_ids
+            RETURN e, dest
+        """
+        result_set = g.query(cypher, {"node_ids": node_ids}).result_set
+
+        result = {"nodes": [], "edges": []}
+        for edge, dest_node in result_set:
+            result["nodes"].append(_encode_node(dest_node))
+            result["edges"].append(_encode_edge(edge))
+    except Exception as e:
+        _json_error(str(e))
+
+    _json_out({"repo": name, **result})
+
+
+# ---------------------------------------------------------------------------
+# paths
+# ---------------------------------------------------------------------------
+
+@app.command()
+def paths(
+    src: int = typer.Argument(..., help="Source node ID"),
+    dest: int = typer.Argument(..., help="Destination node ID"),
+    repo: Optional[str] = typer.Option(
+        None, "--repo", help="Repository name (defaults to CWD name)"
+    ),
+) -> None:
+    """Find call-chain paths between two nodes."""
+    name = _default_repo(repo)
+    try:
+        db = _db()
+        g = db.select_graph(name)
+
+        cypher = """
+            MATCH (src), (dest)
+            WHERE ID(src) = $src_id AND ID(dest) = $dest_id
+            WITH src, dest
+            MATCH p = (src)-[:CALLS*]->(dest)
+            RETURN p
+        """
+        result_set = g.query(cypher, {"src_id": src, "dest_id": dest}).result_set
+
+        found_paths = []
+        for row in result_set:
+            path = []
+            p = row[0]
+            nodes = p.nodes()
+            edges = p.edges()
+            for n, e in zip(nodes, edges):
+                path.append(_encode_node(n))
+                path.append(_encode_edge(e))
+            if nodes:
+                path.append(_encode_node(nodes[-1]))
+            found_paths.append(path)
+    except Exception as e:
+        _json_error(str(e))
+
+    _json_out({"repo": name, "paths": found_paths})
+
+
+# ---------------------------------------------------------------------------
+# info
+# ---------------------------------------------------------------------------
+
+@app.command()
+def info(
+    repo: Optional[str] = typer.Option(
+        None, "--repo", help="Repository name (defaults to CWD name)"
+    ),
+) -> None:
+    """Show repository statistics and metadata."""
+    name = _default_repo(repo)
+    try:
+        db = _db()
+        g = db.select_graph(name)
+
+        node_count = g.query("MATCH (n) RETURN count(n)").result_set[0][0]
+        edge_count = g.query("MATCH ()-[e]->() RETURN count(e)").result_set[0][0]
+        stats = {"node_count": node_count, "edge_count": edge_count}
+        metadata = _get_repo_info(name) or {}
+    except Exception as e:
+        _json_error(str(e))
+
+    _json_out({"repo": name, **stats, "metadata": metadata})
+
+
+if __name__ == "__main__":
+    app()
diff --git a/cli/pyproject.toml b/cli/pyproject.toml
new file mode 100644
index 0000000..8724c3f
--- /dev/null
+++ b/cli/pyproject.toml
@@ -0,0 +1,25 @@
+[project]
+name = "falkordb-cgraph"
+version = "0.4.2"
+description = "Lightweight CLI for querying FalkorDB code-graph knowledge graphs."
+authors = [{name = "Roi Lipman", email = "roilipman@gmail.com"}]
+readme = "README.md"
+requires-python = ">=3.12,<3.14"
+dependencies = [
+    "falkordb>=1.1.3,<2.0.0",
+    "typer>=0.24.0,<1.0.0",
+    "python-dotenv>=1.0.1,<2.0.0",
+]
+
+[project.scripts]
+cgraph = "cgraph.main:app"
+
+[project.urls]
+Homepage = "https://github.com/FalkorDB/code-graph"
+
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["."]
diff --git a/skills/code-graph/references/management.md b/skills/code-graph/references/management.md
index 739ae0b..97f0fcd 100644
--- a/skills/code-graph/references/management.md
+++ b/skills/code-graph/references/management.md
@@ -17,8 +17,15 @@ npx skills add FalkorDB/code-graph
 ### Install the cgraph CLI
 
 ```bash
-pipx install falkordb-code-graph
+# Lightweight CLI (recommended — fast install, query-only)
+pipx install falkordb-cgraph
 # or
+pip install falkordb-cgraph
+```
+
+For indexing commands (`index`, `index-repo`) install the full server package:
+
+```bash
 pip install falkordb-code-graph
 ```
 
@@ -26,6 +33,8 @@ For development (from a local clone):
 
 ```bash
 cd /path/to/code-graph
+make install-cli   # installs falkordb-cgraph from cli/
+# or for full package:
 uv sync --all-extras
 uv pip install -e .
 ```
@@ -71,15 +80,16 @@ This will:
 Ensure the package is installed and the entry point is on your PATH:
 
 ```bash
-pipx install falkordb-code-graph
+# Lightweight CLI (recommended)
+pipx install falkordb-cgraph
 # or
-pip install falkordb-code-graph
+pip install falkordb-cgraph
 ```
 
 For development:
 
 ```bash
-uv pip install -e .   # from the code-graph repo
+make install-cli   # from the code-graph repo
 ```
 
 ### Connection refused