project-orchestrator – OpenClaw Skill

---

name: project-orchestrator description: AI agent orchestrator with Neo4j knowledge graph, Meilisearch search, and Tree-sitter parsing. Use for coordinating multiple coding agents on complex projects with shared context and plans. metadata: { "openclaw": { "emoji": "🎯", "requires": { "bins": ["docker", "cargo"] } } }

Project Orchestrator

Coordinate multiple AI coding agents with a shared knowledge base.

Features

• Multi-Project Support: Manage multiple codebases with isolated data
• Neo4j Knowledge Graph: Code structure, relationships, plans, decisions
• Meilisearch: Fast semantic search across code and decisions
• Tree-sitter: Precise code parsing for 12 languages
• Plan Management: Structured tasks with dependencies and constraints
• MCP Integration: 62 tools for Claude Code, OpenAI Agents, and Cursor

Documentation

• Installation Guide
• Getting Started Tutorial
• API Reference
• MCP Tools Reference
• Integration Guides: Claude Code | OpenAI | Cursor

Quick Start

1. Start the backends

cd {baseDir}
docker compose up -d neo4j meilisearch

2. Build and run the orchestrator

cargo build --release
./target/release/orchestrator serve

Or with Docker:

docker compose up -d

3. Sync your codebase

# Via CLI
./target/release/orch sync --path /path/to/project

# Via API
curl -X POST http://localhost:8080/api/sync \
  -H "Content-Type: application/json" \
  -d '{"path": "/path/to/project"}'

Usage

Create a project

# Create a new project
curl -X POST http://localhost:8080/api/projects \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Embryon",
    "root_path": "/Users/triviere/projects/embryon",
    "description": "Neural network composition framework"
  }'

# List all projects
curl http://localhost:8080/api/projects

# Sync a project
curl -X POST http://localhost:8080/api/projects/embryon/sync

# Search code within a project
curl "http://localhost:8080/api/projects/embryon/code/search?q=tensor&limit=10"

Create a plan

orch plan create \
  --title "Implement GPU Backend" \
  --desc "Add Metal GPU support for neural network operations" \
  --priority 10

Add tasks to the plan

orch task add \
  --plan <plan-id> \
  --desc "Implement MatMul Metal shader"

orch task add \
  --plan <plan-id> \
  --desc "Add attention layer GPU support" \
  --depends <task-1-id>

Get context for an agent

# JSON context
orch context --plan <plan-id> --task <task-id>

# Ready-to-use prompt
orch context --plan <plan-id> --task <task-id> --prompt

Record decisions

orch decision add \
  --task <task-id> \
  --desc "Use shared memory for tile-based MatMul" \
  --rationale "Better cache locality, 2x performance improvement"

Search past decisions

orch decision search "memory management GPU"

API Endpoints

Projects (Multi-Project Support)

Method	Path	Description
GET	/api/projects	List all projects
POST	/api/projects	Create a new project
GET	/api/projects/{slug}	Get project by slug
DELETE	/api/projects/{slug}	Delete a project
POST	/api/projects/{slug}/sync	Sync project's codebase
GET	/api/projects/{slug}/plans	List project's plans
GET	/api/projects/{slug}/code/search	Search code in project

Plans & Tasks

Method	Path	Description
GET	/health	Health check
GET	/api/plans	List active plans
POST	/api/plans	Create plan
GET	/api/plans/{id}	Get plan details
PATCH	/api/plans/{id}	Update plan status
GET	/api/plans/{id}/next-task	Get next available task
POST	/api/plans/{id}/tasks	Add task to plan
GET	/api/tasks/{id}	Get task details
PATCH	/api/tasks/{id}	Update task
GET	/api/plans/{plan}/tasks/{task}/context	Get task context
GET	/api/plans/{plan}/tasks/{task}/prompt	Get generated prompt
POST	/api/tasks/{id}/decisions	Add decision
GET	/api/decisions/search?q=...	Search decisions

Sync & Watch

Method	Path	Description
POST	/api/sync	Sync directory to knowledge base
GET	/api/watch	Get file watcher status
POST	/api/watch	Start watching a directory
DELETE	/api/watch	Stop file watcher
POST	/api/wake	Agent completion webhook

Code Exploration (Graph + Search)

Method	Path	Description
GET	/api/code/search?q=...	Semantic code search
GET	/api/code/symbols/{path}	Get symbols in a file
GET	/api/code/references?symbol=...	Find all references to a symbol
GET	/api/code/dependencies/{path}	Get file import/dependent graph
GET	/api/code/callgraph?function=...	Get function call graph
GET	/api/code/impact?target=...	Analyze change impact
GET	/api/code/architecture	Get codebase overview
POST	/api/code/similar	Find similar code snippets
GET	/api/code/trait-impls?trait_name=...	Find types implementing a trait
GET	/api/code/type-traits?type_name=...	Find traits implemented by a type
GET	/api/code/impl-blocks?type_name=...	Get all impl blocks for a type

Auto-Sync with File Watcher

Keep the knowledge base updated automatically while coding:

# Start watching a project directory
curl -X POST http://localhost:8080/api/watch \
  -H "Content-Type: application/json" \
  -d '{"path": "/path/to/project"}'

# Check watcher status
curl http://localhost:8080/api/watch

# Stop watching
curl -X DELETE http://localhost:8080/api/watch

The watcher automatically syncs .rs, .ts, .tsx, .js, .jsx, .py, .go files when modified. It ignores node_modules/, target/, .git/, __pycache__/, dist/, build/.

Code Exploration

Query the code graph instead of reading files directly:

# Semantic search across code
curl "http://localhost:8080/api/code/search?q=error+handling&language=rust&limit=10"

# Get symbols in a file (functions, structs, etc.)
curl "http://localhost:8080/api/code/symbols/src%2Flib.rs"

# Find all references to a symbol
curl "http://localhost:8080/api/code/references?symbol=AppState&limit=20"

# Get file dependencies (imports and dependents)
curl "http://localhost:8080/api/code/dependencies/src%2Fneo4j%2Fclient.rs"

# Get call graph for a function
curl "http://localhost:8080/api/code/callgraph?function=handle_request&depth=2&direction=both"

# Analyze impact before changing a file
curl "http://localhost:8080/api/code/impact?target=src/lib.rs&target_type=file"

# Get architecture overview
curl "http://localhost:8080/api/code/architecture"

# Find similar code patterns
curl -X POST http://localhost:8080/api/code/similar \
  -H "Content-Type: application/json" \
  -d '{"snippet": "async fn handle_error", "limit": 5}'

# Find all types implementing a trait
curl "http://localhost:8080/api/code/trait-impls?trait_name=Module"

# Find all traits implemented by a type
curl "http://localhost:8080/api/code/type-traits?type_name=Orchestrator"

# Get all impl blocks for a type
curl "http://localhost:8080/api/code/impl-blocks?type_name=Neo4jClient"

For Agents

Getting context before starting work

# Fetch your task context
curl http://localhost:8080/api/plans/$PLAN_ID/tasks/$TASK_ID/prompt

Recording decisions while working

curl -X POST http://localhost:8080/api/tasks/$TASK_ID/decisions \
  -H "Content-Type: application/json" \
  -d '{
    "description": "Chose X over Y",
    "rationale": "Because..."
  }'

Notifying completion

curl -X POST http://localhost:8080/api/wake \
  -H "Content-Type: application/json" \
  -d '{
    "task_id": "'$TASK_ID'",
    "success": true,
    "summary": "Implemented feature X",
    "files_modified": ["src/foo.rs", "src/bar.rs"]
  }'

Configuration

Environment variables:

Variable	Default	Description
NEO4J_URI	bolt://localhost:7687	Neo4j connection URI
NEO4J_USER	neo4j	Neo4j username
NEO4J_PASSWORD	orchestrator123	Neo4j password
MEILISEARCH_URL	http://localhost:7700	Meilisearch URL
MEILISEARCH_KEY	orchestrator-meili-key-change-me	Meilisearch API key
WORKSPACE_PATH	.	Default workspace path
SERVER_PORT	8080	Server port
RUST_LOG	info	Log level

Architecture

┌─────────────────────────────────────────────────────────────┐
│                    ORCHESTRATOR API                          │
│                    (localhost:8080)                          │
└─────────────────────────────┬───────────────────────────────┘
                              │
        ┌─────────────────────┼─────────────────────┐
        ▼                     ▼                     ▼
┌───────────────┐     ┌───────────────┐     ┌───────────────┐
│    NEO4J      │     │  MEILISEARCH  │     │  TREE-SITTER  │
│   (7687)      │     │    (7700)     │     │   (in-proc)   │
│               │     │               │     │               │
│ • Code graph  │     │ • Code search │     │ • AST parsing │
│ • Plans       │     │ • Decisions   │     │ • Symbols     │
│ • Decisions   │     │ • Logs        │     │ • Complexity  │
│ • Relations   │     │               │     │               │
└───────────────┘     └───────────────┘     └───────────────┘

Development

# Run tests
cargo test

# Run with debug logging
RUST_LOG=debug cargo run -- serve

# Format code
cargo fmt

# Lint
cargo clippy

Project Orchestrator

Coordinate AI coding agents with a shared knowledge graph.

Project Orchestrator gives your AI agents a shared brain. Instead of each agent starting from scratch, they share code understanding, plans, decisions, and progress through a central knowledge base.

---

Features

• Shared Knowledge Base — Code structure stored in Neo4j graph database, accessible to all agents
• Semantic Code Search — Find code by meaning, not just keywords, powered by Meilisearch
• Plan & Task Management — Structured workflows with dependencies, steps, and progress tracking
• Multi-Language Parsing — Tree-sitter support for Rust, TypeScript, Python, Go, and 8 more languages
• Multi-Project Workspaces — Group related projects with shared context, contracts, and milestones
• MCP Integration — 113 tools available for Claude Code, OpenAI Agents, and Cursor
• Auto-Sync — File watcher keeps the knowledge base updated as you code

---

Quick Start

1. Start the backend services

git clone https://github.com/your-org/project-orchestrator.git
cd project-orchestrator
docker compose up -d

2. Configure your AI tool

Add to your MCP configuration (e.g., ~/.claude/mcp.json):

{
  "mcpServers": {
    "project-orchestrator": {
      "command": "/path/to/mcp_server",
      "env": {
        "NEO4J_URI": "bolt://localhost:7687",
        "NEO4J_USER": "neo4j",
        "NEO4J_PASSWORD": "orchestrator123",
        "MEILISEARCH_URL": "http://localhost:7700",
        "MEILISEARCH_KEY": "orchestrator-meili-key-change-me"
      }
    }
  }
}

3. Create and sync your first project

# Your AI agent can now use MCP tools to:
# - create_project: Register your codebase
# - sync_project: Parse and index your code
# - create_plan: Start a development plan
# - create_workspace: Group related projects
# - And 108 more tools...

That's it! Your AI agents now have shared context.

---

Integrations

Platform	Status	Documentation
Claude Code	Full Support	Setup Guide
OpenAI Agents	Full Support	Setup Guide
Cursor	Full Support	Setup Guide

---

What Can Your Agents Do?

Explore Code

"Find all functions that handle authentication"
"Show me what imports this file"
"What's the impact of changing UserService?"

Manage Work

"Create a plan to add OAuth support"
"What's the next task I should work on?"
"Record that we chose JWT over sessions"

Stay in Sync

"What decisions were made about caching?"
"Show me the project roadmap"
"What tasks are blocking the release?"

Coordinate Multiple Projects

"Create a workspace for our microservices"
"Add the API contract shared by all services"
"What's the cross-project milestone progress?"

---

Documentation

Guide	Description
Installation	Full setup instructions and configuration
Getting Started	Step-by-step tutorial for new users
API Reference	Complete REST API documentation
MCP Tools	All 113 MCP tools with examples
Workspaces	Multi-project coordination
Multi-Agent Workflows	Coordinating multiple agents

---

Architecture

┌─────────────────────────────────────────────────────────────┐
│                     YOUR AI AGENTS                          │
│           (Claude Code / OpenAI / Cursor)                   │
└─────────────────────────────┬───────────────────────────────┘
                              │ MCP Protocol
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                  PROJECT ORCHESTRATOR                        │
│                   (113 MCP Tools)                           │
└─────────────────────────────┬───────────────────────────────┘
                              │
        ┌─────────────────────┼─────────────────────┐
        ▼                     ▼                     ▼
┌───────────────┐     ┌───────────────┐     ┌───────────────┐
│    NEO4J      │     │  MEILISEARCH  │     │  TREE-SITTER  │
│               │     │               │     │               │
│ • Code graph  │     │ • Code search │     │ • 12 languages│
│ • Plans       │     │ • Decisions   │     │ • AST parsing │
│ • Decisions   │     │               │     │ • Symbols     │
└───────────────┘     └───────────────┘     └───────────────┘

---

Supported Languages

Language	Extensions
Rust	.rs
TypeScript	.ts, .tsx
JavaScript	.js, .jsx
Python	.py
Go	.go
Java	.java
C/C++	.c, .h, .cpp, .cc, .hpp
Ruby	.rb
PHP	.php
Kotlin	.kt, .kts
Swift	.swift
Bash	.sh, .bash

---

Contributing

Contributions are welcome! See CONTRIBUTING.md for guidelines.

License

MIT License - see LICENSE for details.

---

<p align="center"> <i>Give your AI agents a shared brain.</i> </p>