How to Deploy Graphify: Docker and Local Installation Guide

Deploy Graphify using Docker with docker build -t graphify . and docker run, or install the graphifyy package via uv tool install graphifyy, pipx install graphifyy, or pip install graphifyy to run the CLI server locally.

Graphify is a Python-based knowledge-graph engine that serves graph data via HTTP or STDIO endpoints. Available in the Graphify-Labs/graphify repository, it supports containerized production deployments and direct installation on development machines. This guide explains how to deploy Graphify using Docker, uv, pipx, or pip based on the source code in README.md and Dockerfile.

Docker-Based Deployment (Recommended for Production)

Containerization provides a reproducible environment for running the Graphify server. The repository includes a Dockerfile that defines a minimal image running the graphify CLI.

Building the Container Image

Build the Docker image from the repository root:

docker build -t graphify .

Source: Docker build instructions are documented in README.md lines 75-77 according to the Graphify-Labs/graphify source code.

Running the Container with HTTP Transport

Expose the HTTP server on port 8080 with a persistent volume for the graph data:

docker run -p 8080:8080 -v "$(pwd)/graphify-out:/data" graphify \
  /data/graph.json --transport http --host 0.0.0.0 --api-key "$SECRET"

This command:

• Maps port 8080 between host and container
• Mounts ./graphify-out to /data for persistent storage of graph.json
• Sets --transport http to enable HTTP mode instead of default STDIO
• Binds to --host 0.0.0.0 to accept external connections
• Secures the endpoint with --api-key

Source: Full run command details appear in README.md lines 73-79.

Configuring Environment Variables

Pass LLM backend credentials using -e flags:

docker run -e OPENAI_API_KEY=sk-... -e GRAPHIFY_MAX_WORKERS=8 \
  -p 8080:8080 graphify /data/graph.json --transport http

Available environment variables are documented in the environment-variables table in README.md lines 88-106, including options for API keys and worker configuration.

Local Installation Methods

For development or native process deployment, install the graphifyy package (note the double 'y') directly on your host system.

Install with uv (Recommended)

The uv tool provides the fastest installation method:

uv tool install graphifyy
uv tool update-shell
graphify --help

After installation, run the server directly:

graphify . --transport http --host 0.0.0.0 --port 8080 --api-key "$SECRET"

Source: Installation troubleshooting notes in README.md lines 44-47.

Install with pipx

For isolated tool installation without affecting system Python:

pipx install graphifyy
pipx ensurepath
graphify --version

Source: README.md lines 44-47 cover pipx in the installation table.

Install with pip

Standard pip installation works for virtual environments:

pip install graphifyy
python -m graphify --transport stdio

You may need to add ~/.local/bin (Linux) or ~/Library/Python/3.x/bin (macOS) to your PATH to access the graphify executable.

Source: Path configuration notes in README.md lines 45-46.

WSL and Linux Virtual Environment Setup

Ubuntu systems ship python3 without a python symlink. Create an isolated virtual environment to avoid conflicts:

python3 -m venv .venv
.venv/bin/pip install "graphifyy[mcp]"

Source: WSL-specific guidance in README.md lines 81-84.

Key Deployment Files

Understanding these repository files helps customize your deployment:

• README.md: Central documentation for Docker commands, environment variables, and installation options (lines 44-106)
• Dockerfile: Defines the minimal container image build process
• docs/docker-mcp-sqlite.md: Advanced configuration for Docker-MCP Toolkit integration with data-store backends

Verifying Your Deployment

Test your Graphify instance using curl:

curl http://localhost:8080/mcp/graph.json

Or query using the Graphify CLI:

graphify query "your query here"

Summary

• Docker deployment uses docker build -t graphify . and docker run -p 8080:8080 with volume mounts for persistent storage
• Package installation requires the graphifyy package (not graphify) available via uv, pipx, or pip
• Transport modes include HTTP (--transport http) for network access or STDIO for local process communication
• Security requires --api-key for HTTP endpoints and environment variables like OPENAI_API_KEY for LLM functionality
• Key files include README.md (lines 73-106), Dockerfile, and docs/docker-mcp-sqlite.md

Frequently Asked Questions

What is the difference between the graphify command and the graphifyy package?

The Python package is named graphifyy (with two y's) on PyPI, while the installed CLI command is graphify (one y). When installing, use pip install graphifyy or uv tool install graphifyy, but execute the tool using the graphify command.

How do I persist graph data when using Docker?

Mount a host directory to /data in the container using the -v "$(pwd)/graphify-out:/data" flag. This ensures your graph.json file survives container restarts. The README.md lines 73-79 demonstrate mounting the volume when running docker run.

Can I run Graphify without Docker?

Yes. Install the graphifyy package using uv tool install, pipx install, or pip install, then run graphify . --transport http --host 0.0.0.0. This starts a native HTTP server without containerization, suitable for development or production on systems where Docker is unavailable.

Which transport mode should I use: HTTP or STDIO?

Use HTTP (--transport http) for production deployments and remote access, binding to --host 0.0.0.0 and securing with --api-key. Use STDIO (the default) for local development, CI pipelines, or when integrating with tools that communicate via standard input/output streams.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}