project-orchestratorAI 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.
Install via ClawdBot CLI:
clawdbot install reversTeam/project-orchestratorCoordinate multiple AI coding agents with a shared knowledge base.
cd {baseDir}
docker compose up -d neo4j meilisearchcargo build --release
./target/release/orchestrator serveOr with Docker:
docker compose up -d# 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"}'# 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"orch plan create \
--title "Implement GPU Backend" \
--desc "Add Metal GPU support for neural network operations" \
--priority 10orch 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># JSON context
orch context --plan <plan-id> --task <task-id>
# Ready-to-use prompt
orch context --plan <plan-id> --task <task-id> --promptorch decision add \
--task <task-id> \
--desc "Use shared memory for tile-based MatMul" \
--rationale "Better cache locality, 2x performance improvement"orch decision search "memory management GPU"| 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 |
| 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 |
| 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 |
| 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 |
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/watchThe watcher automatically syncs .rs, .ts, .tsx, .js, .jsx, .py, .go files when modified.
It ignores node_modules/, target/, .git/, pycache/, dist/, build/.
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"# Fetch your task context
curl http://localhost:8080/api/plans/$PLAN_ID/tasks/$TASK_ID/promptcurl -X POST http://localhost:8080/api/tasks/$TASK_ID/decisions \
-H "Content-Type: application/json" \
-d '{
"description": "Chose X over Y",
"rationale": "Because..."
}'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"]
}'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 |
āāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāā
ā 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 ā ā ā ā ā
āāāāāāāāāāāāāāāāā āāāāāāāāāāāāāāāāā āāāāāāāāāāāāāāāāā# Run tests
cargo test
# Run with debug logging
RUST_LOG=debug cargo run -- serve
# Format code
cargo fmt
# Lint
cargo clippyGenerated Mar 1, 2026
Large teams can coordinate multiple AI coding agents on complex enterprise applications, using the knowledge graph to track code relationships and decisions across microservices. The multi-project support allows managing separate codebases for frontend, backend, and infrastructure with shared context, improving consistency and reducing duplication.
Research teams can use the orchestrator to manage AI model codebases, with Tree-sitter parsing for languages like Python and C++ to analyze neural network implementations. The plan management feature helps structure experiments, track tasks like hyperparameter tuning, and record decisions on architecture choices for reproducibility.
Maintainers of open-source projects can sync codebases to the knowledge graph for semantic search across contributions and decisions, facilitating onboarding of new contributors. The MCP integration with tools like Claude Code enables automated code reviews and issue triaging, while the file watcher keeps the knowledge base updated in real-time.
Educational institutions can build coding platforms where instructors use the orchestrator to create structured lesson plans with tasks and dependencies, while students interact via API to get context and submit code. The Neo4j graph helps visualize learning progress and code relationships, enhancing collaborative learning experiences.
DevOps teams can orchestrate AI agents to automate infrastructure-as-code projects, using the knowledge graph to map dependencies between services and configurations. The search functionality allows quick retrieval of past decisions on scaling or security implementations, and the sync feature integrates with CI/CD pipelines for continuous updates.
Offer the orchestrator as a cloud-hosted service with tiered pricing based on projects, agents, and API usage, targeting enterprises needing scalable AI coordination. Revenue comes from monthly subscriptions, with premium features like advanced analytics and priority support.
Sell on-premise licenses to large organizations with strict data privacy requirements, including custom integrations and dedicated support. Revenue is generated through one-time license fees and annual maintenance contracts, with upsells for training and consulting services.
Provide a free open-source version with basic features to build a community, then monetize through paid add-ons like enhanced MCP tools, premium integrations, and advanced analytics. Revenue streams include in-app purchases and marketplace commissions for third-party extensions.
š¬ Integration Tip
Leverage the MCP tools for seamless integration with existing AI agents like Claude Code, and use the file watcher to automate knowledge base updates during active development cycles.
Captures learnings, errors, and corrections to enable continuous improvement. Use when: (1) A command or operation fails unexpectedly, (2) User corrects Clau...
Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill.
Search and analyze your own session logs (older/parent conversations) using jq.
Typed knowledge graph for structured agent memory and composable skills. Use when creating/querying entities (Person, Project, Task, Event, Document), linking related objects, enforcing constraints, planning multi-step actions as graph transformations, or when skills need to share state. Trigger on "remember", "what do I know about", "link X to Y", "show dependencies", entity CRUD, or cross-skill data access.
Ultimate AI agent memory system for Cursor, Claude, ChatGPT & Copilot. WAL protocol + vector search + git-notes + cloud backup. Never lose context again. Vibe-coding ready.
Headless browser automation CLI optimized for AI agents with accessibility tree snapshots and ref-based element selection