Graphoni is a graph-based wiki web app. It lets teams build, explore, and curate knowledge graphs through a browser — the same way a traditional wiki lets you collaboratively edit text. It's not tied to any specific domain: anything that makes sense as a graph — people and relationships, infrastructure dependencies, research citations, corporate ownership structures — can be a Graphoni wiki.

The graph is stored in Neo4j (a Cypher graph database) and rendered in real-time with Sigma.js over WebGL. Nodes and edges are color-coded by type, laid out with ForceAtlas2, and organized into communities you can zoom into. Click any node to see its properties, connections, and linked documents.

Views are saved queries on the graph. A view might show only money transfers, or messages between people, or ownership chains — any subgraph you can express as a Cypher query. Views can be saved by slug and shared as links.

Editing follows a proposal-based workflow: users suggest changes with a reason, moderators review and approve them, and approved edits are automatically applied as Cypher queries. Admins can bypass review for direct edits. Every mutation is recorded in a PostgreSQL audit log.

The API exposes everything programmatically — query the graph, submit proposals, and approve edits without touching the UI. This makes it possible to build automations, bulk-import data, or integrate with other tools.

Early stage. The core components are connected and working: graph rendering, authentication, proposal workflow, moderation queue, audit log, saved views, and the API. Next up:

• Custom views — richer saved queries with filtered graph rendering
• AI chat — ask the graph questions in natural language and get back relevant subgraphs

1. User submits a proposal (edit-node, add-node, delete-node, add/edit/delete-edge)
2. Proposal stored in PostgreSQL with status: pending, current graph state captured as dataBefore
3. Mod reviews and approves/rejects
4. On approval: Cypher auto-executed against Neo4j, status: applied, audit log written
5. Admin can bypass review with "Apply Directly" option (still audit-logged)

• Node.js 20+
• Docker and Docker Compose
• Python 3.10+ (for ETL only)

docker compose up -d neo4j postgres

This starts:

• Neo4j — Bolt on localhost:7687, Browser UI on localhost:7474
• PostgreSQL — localhost:5432 (user: graphoni, password: graphoni_dev, db: graphoni)

cd web
npm install

# Push schema to PostgreSQL (creates all tables)
npm run db:push

# Seed admin and mod users
npm run db:seed

This creates two dev users:

• admin@graphoni.local (admin role)
• mod@graphoni.local (mod role)

The default .env.local works out of the box for local development:

NEO4J_URI=bolt://localhost:7687
DATABASE_URL=postgresql://graphoni:graphoni_dev@localhost:5432/graphoni
NEXTAUTH_URL=http://localhost:3001
NEXTAUTH_SECRET=dev-secret-please-change-in-production-abc123

For GitHub OAuth (optional in dev), add:

GITHUB_ID=your_github_oauth_app_id
GITHUB_SECRET=your_github_oauth_app_secret

# Install Python deps
pip install -r requirements.txt

# Load seed data into Neo4j + export JSON
python graph.py init
python graph.py export-json

Or skip this step — the frontend falls back to public/data/graph.json if Neo4j has no data.

cd web
npm run dev

Open http://localhost:3001.

In development, the sign-in page (/auth/signin) has a "Dev Login" form. Enter any of:

• admin@graphoni.local — admin role
• mod@graphoni.local — mod role
• Any email — auto-creates a user account

npm run db:push      # Push schema changes to PostgreSQL
npm run db:generate  # Generate migration files from schema changes
npm run db:migrate   # Run pending migrations
npm run db:studio    # Open Drizzle Studio (browser-based DB explorer)
npm run db:seed      # Re-seed admin/mod users

Create a .env file in the project root:

NEXTAUTH_SECRET=generate-a-real-secret-here
GITHUB_ID=your_github_oauth_app_id
GITHUB_SECRET=your_github_oauth_app_secret

Generate a secret with: openssl rand -base64 32

docker compose up -d

This starts all three services:

• neo4j on port 7687 (Bolt) and 7474 (Browser UI)
• postgres on port 5432
• web on port 3001

The web container automatically runs database migrations on startup via scripts/start.sh.

# Run seed from inside the web container
docker compose exec web npx tsx lib/db/seed.ts

# From host, with Python deps installed
NEO4J_URI=bolt://localhost:7687 python graph.py init

The app is now live at http://localhost:3001.

Build and push the web image:

cd web
docker build -t graphoni:latest .

The image runs migrations on startup, so just point DATABASE_URL at your PostgreSQL instance.

1. Go to GitHub > Settings > Developer settings > OAuth Apps > New OAuth App
2. Set Homepage URL to your production URL
3. Set Authorization callback URL to https://your-domain.com/api/auth/callback/github
4. Copy the Client ID and Client Secret into your env vars

uv tool install git+https://github.com/gwbischof/graphoni
# Or from local clone
uv tool install ./

graphoni search "epstein"
graphoni node jeffrey_epstein --hops 2
graphoni path jeffrey_epstein ghislaine_maxwell
graphoni stats
graphoni add-node --label "New Person" --type Person --reason "..."
graphoni proposals --status pending
graphoni approve <id> --comment "looks good"

claude mcp add -s user graphoni -- uvx --from "git+https://github.com/gwbischof/graphoni" graphoni-mcp

{
  "mcpServers": {
    "graphoni": {
      "command": "graphoni-mcp",
      "env": {
        "GRAPHONI_URL": "http://localhost:3001",
        "GRAPHONI_API_KEY": "gk_..."
      }
    }
  }
}

mcp dev mcp_server.py

from client import GraphoniClient

client = GraphoniClient("http://localhost:3001", api_key="gk_...")

# Search
results = client.search("Maxwell", limit=10)

# Get node neighborhood
data = client.get_node("jeffrey_epstein", hops=2)

# Complex query
data = client.query({"type": "structured", "nodeTypes": ["Person"], "centerNode": "jeffrey_epstein", "hops": 2})

# Submit edit proposal
client.add_node(label="New Person", node_type="Person", reason="Adding new source")

# Approve proposal
client.approve_proposal("uuid-here", comment="Verified")

• Graph visualization — Sigma.js with ForceAtlas2 layout, color-coded by type/role
• Hierarchical zoom — Community supernodes that expand on double-click
• Search — Highlights matching nodes across label, ID, notes
• Filters — Toggle node subtypes and edge types
• Detail panel — Click any node to see properties, connections, quotes, doc links
• Saved views — Save and share graph queries by slug
• Edit proposals — Users suggest changes, mods approve, auto-applied as Cypher
• Admin direct edits — Admins bypass review, still audit-logged
• Audit log — Full history of all graph mutations with executed Cypher
• REST API — Query the graph, submit proposals, and approve edits programmatically
• GitHub OAuth — Production auth with role-based access control

• Custom views — Richer saved queries with filtered subgraph rendering
• AI chat — Natural language queries that return relevant subgraphs

• Next.js 16 — App Router, React 19
• Sigma.js — WebGL graph rendering
• NextAuth.js v5 — Authentication (GitHub OAuth + dev credentials)
• Drizzle ORM — Type-safe PostgreSQL queries
• PostgreSQL 16 — Users, proposals, audit trail
• Neo4j Community Edition — Graph database (Cypher, Bolt protocol)
• Framer Motion — Panel animations, starfield parallax
• shadcn/ui — UI components (Radix primitives)
• Tailwind CSS 4 — Styling
• Docker Compose — Multi-service orchestration