डेवलपर्स के लिए

अपने असिस्टेंट को अपने प्लान वाले ग्राफ़ से जोड़ें

Project Orchestrator ऐप का हर काम MCP टूल, एक REST API और दो WebSocket स्ट्रीम के रूप में उपलब्ध कराता है। एक Rust सर्वर कोड, प्लान, निर्णय और नोट को Neo4j ग्राफ़ और Meilisearch में रखता है।

MCP क्लाइंट जोड़ें टूल देखें

MCP टूल: 31; MCP टूल
इनमें कुल actions: 402; इनमें कुल actions
पार्स की जाने वाली भाषाएँ: 17; पार्स की जाने वाली भाषाएँ
WebSocket स्ट्रीम: 3; WebSocket स्ट्रीम

प्रोडक्ट ढूँढ रहे हैं? होम पेज पर लौटें।

project(action: "sync", slug: "my-app")

code(
  action: "analyze_impact",
  target: "src/session.rs",
  project_slug: "my-app"
)

plan(action: "run", plan_id: "<uuid>")

कनेक्ट करें

PO को MCP क्लाइंट से जोड़ें

डेस्कटॉप ऐप या सर्वर चल रहा होना चाहिए। फिर एक कमांड PO को Claude Code में दर्ज कर देती है, या किसी और MCP क्लाइंट के लिए आप एंट्री खुद जोड़ते हैं।

सर्वर इंस्टॉल करें और शुरू करें

सर्वर को Neo4j और Meilisearch चाहिए। NATS वैकल्पिक है। रिपॉज़िटरी तीनों के लिए एक docker-compose.yml देती है।

orchestrator serve

# needs Neo4j and Meilisearch: docker compose up -d$brew install this-rs/tap/project-orchestrator$orchestrator serve --port 8080

PO को Claude Code में दर्ज करें

यह MCP एंट्री stdio मोड में लिखता है, इस सर्वर के URL और उसके auth सीक्रेट के साथ, और टूल को पहले से मंज़ूर कर देता है।

orchestrator setup-claude

$orchestrator setup-claude --port 8080

setup-claude ~/.claude/settings.json के अनुमत टूल में mcp__project-orchestrator__* भी जोड़ देता है, ताकि Claude Code हर कॉल से पहले न पूछे।

जाँचें कि चल रहा है

Claude Code में /mcp चलाएँ: project-orchestrator सूची में दिखना चाहिए। फिर प्रोजेक्ट की सूची माँगें: Claude project(action: "list") कॉल करता है।

Claude Code

# in Claude Code/mcp# then ask: "List all registered projects"# Claude calls: project(action: "list")

कोई भी MCP क्लाइंट, stdio

mcp_server एक पतला प्रॉक्सी है: वह stdio पर MCP बोलता है और हर कॉल REST API को भेज देता है। वह खुद Neo4j से कभी नहीं जुड़ता। PO_AUTH_TOKEN सेट करें, या PO_JWT_SECRET सेट करें ताकि वह शुरू होते समय टोकन बना ले।

~/.claude/mcp.json

{  "mcpServers": {    "project-orchestrator": {      "command": "/path/to/mcp_server",      "env": {        "PO_SERVER_URL": "http://127.0.0.1:8080",        "PO_AUTH_TOKEN": "<jwt-session-token>"      }    }  }}

रिमोट क्लाइंट, Streamable HTTP

सर्वर POST /mcp पर भी MCP का जवाब देता है, REST API जैसे ही ऑथेंटिकेशन के पीछे। एक सेशन आईडी Mcp-Session-Id हेडर में लौटाई जाती है और हर अनुरोध के साथ वापस भेजनी होती है।

Claude Code

$claude mcp add --transport http project-orchestrator http://127.0.0.1:8080/mcp \$  --header "Authorization: Bearer <token>"

HTTP

POST /mcpAuthorization: Bearer <token>Content-Type: application/json{"jsonrpc":"2.0","id":1,"method":"tools/list"}

MCP टूल

31 टूल, कॉल का एक ही रूप

हर टूल एक action पैरामीटर लेता है और एक ऑपरेशन तक पहुँचता है। टूल, action या पैरामीटर से खोजें, फिर सटीक कॉल कॉपी करें।

31 टूल

plan

Plans with dependency graph, waves, critical path, and the autonomous runner.

प्लानिंग और डिलीवरी 27 actions

उदाहरण कॉल

plan(  action: "create",  title: "Migrate session store to Redis",  priority: 8)

Actions

+21 और

पैरामीटर

plan_idproject_idtitledescriptionpriorityconstraintsstatussearchlimitoffsetsort_bysort_orderpriority_minpriority_maxcwdproject_slugtrigger_idtrigger_typeconfigcooldown_secsrun_idrun_idstask_idparent_session_idcustom_sections

<uuid> जैसे आर्ग्युमेंट मान प्लेसहोल्डर हैं। action और पैरामीटर के नाम सर्वर के सोर्स से पढ़े गए हैं।

आर्किटेक्चर

एक Rust सर्वर, तीन स्टोर, कोई भी क्लाइंट

क्लाइंट कभी डेटाबेस को नहीं छूते। वे सर्वर से बात करते हैं, जो कोड पार्स करता है, API देता है और इवेंट स्ट्रीम करता है।

MCP clients
Claude Code, Cursor या कोई भी MCP क्लाइंट। वे stdio पर mcp_server से MCP में बात करते हैं, या HTTP पर POST /mcp से।
Desktop app
Tauri 2 ऐप इंटरफ़ेस को अपने में रखता है और सर्वर शुरू करता है। वह Neo4j और Meilisearch कंटेनर Docker से सँभालता है।
WebSocket clients
कुछ भी जो /ws/chat/{session_id}, /ws/events या /ws/run/{run_id} खोलता है।
mcp_server
बाइनरी mcp_server: अंदर stdio पर MCP, बाहर REST कॉल। कोई स्टेट नहीं रखता।
orchestrator
ऑर्केस्ट्रेटर बाइनरी (axum)। REST API, चैट मैनेजर, प्लान रनर, tree-sitter पार्सर, इवेंट बस।
Neo4j
ग्राफ़: कोड, प्लान, टास्क, निर्णय, नोट, स्किल, प्रोटोकॉल, चैट सेशन।
Meilisearch
कोड, नोट, निर्णय और चैट संदेशों में फ़ुल-टेक्स्ट सर्च।
NATSवैकल्पिक
कई सर्वर इंस्टेंस के बीच इवेंट सिंक करता है और चैट आगे पहुँचाता है। इसके बिना सर्वर सिर्फ़ लोकल चलता है।
Claude
चैट मैनेजर nexus-claude SDK से Claude को चलाता है।

वे कैसे बात करते हैं

MCP clients / mcp_serverstdio
MCP clients / orchestratorHTTP /mcp
mcp_server / orchestratorREST
Desktop app / orchestratorREST + WebSocket
WebSocket clients / orchestratorWebSocket
orchestrator / Neo4jbolt
orchestrator / MeilisearchHTTP
orchestrator / NATSNATS
orchestrator / ClaudeSDK

कोड पार्सिंग

17 भाषाएँ, tree-sitter से पार्स

हर फ़ाइल को फ़ंक्शन, स्ट्रक्ट, ट्रेट, एनम, इंपोर्ट, impl ब्लॉक और कॉल एज में पार्स किया जाता है, फिर ग्राफ़ में रखा जाता है।

17 भाषाएँ

Rust
एक्सटेंशन: .rs
tree-sitter-rust
TypeScript / JavaScript
एक्सटेंशन: .ts .tsx .js .jsx .mjs .cjs
tree-sitter-typescript
Python
एक्सटेंशन: .py .pyi
tree-sitter-python
Go
एक्सटेंशन: .go
tree-sitter-go
Java
एक्सटेंशन: .java
tree-sitter-java
C
एक्सटेंशन: .c .h
tree-sitter-c
C++
एक्सटेंशन: .cpp .cc .cxx .hpp .hxx .hh
tree-sitter-cpp
Ruby
एक्सटेंशन: .rb .rake .gemspec
tree-sitter-ruby
PHP
एक्सटेंशन: .php .phtml .php5 .php7
tree-sitter-php
Kotlin
एक्सटेंशन: .kt .kts
tree-sitter-kotlin-ng
Swift
एक्सटेंशन: .swift
tree-sitter-swift
Bash
एक्सटेंशन: .sh .bash .zsh
tree-sitter-bash
C#
एक्सटेंशन: .cs
tree-sitter-c-sharp
Scala
एक्सटेंशन: .scala .sc
tree-sitter-scala
Zig
एक्सटेंशन: .zig
tree-sitter-zig
HCL (Terraform)
एक्सटेंशन: .tf .tfvars
tree-sitter-hcl
Dart
एक्सटेंशन: .dart
tree-sitter-dart

हर फ़ाइल से: फ़ंक्शन, स्ट्रक्ट, ट्रेट, एनम, इंपोर्ट, impl ब्लॉक, और कॉन्फ़िडेंस स्कोर के साथ फ़ंक्शन कॉल।

JavaScript फ़ाइलें (.js, .jsx, .mjs, .cjs) TypeScript ग्रामर से पढ़ी जाती हैं।

API और इवेंट

स्टेट के लिए REST, बदलाव के लिए WebSocket

प्लान, कोड, नोट और बाकी सब HTTP पर सादा JSON हैं। बदलाव WebSocket पर पुश किए जाते हैं।

मुख्य REST एंडपॉइंट

ज़्यादातर रूट auth मिडलवेयर के पीछे हैं। जब कोई auth सेक्शन कॉन्फ़िगर न हो, तो API खुला रहता है।

GET	/health	Liveness
GET	/api/version	Server version
GET	/api/projects	List projects (POST creates)
POST	/api/projects/{slug}/sync	Parse a project into the graph
GET	/api/plans/{plan_id}/waves	Parallel waves of a plan
POST	/api/plans/{plan_id}/run	Start the runner on a plan
GET	/api/code/search	Search code
GET	/api/code/impact	Impact analysis
GET	/api/notes/search	Search notes
GET	/api/decisions/search	Search decisions
POST	/api/reason	Reasoning over the graph
POST	/mcp	MCP over Streamable HTTP

WebSocket स्ट्रीम

/ws/events
हर create, update, delete, link, unlink और स्थिति का बदलाव, एक JSON इवेंट के रूप में। entity_types, project_id और layers क्वेरी पैरामीटर से फ़िल्टर करें।
/ws/chat/{session_id}
Claude के साथ बातचीत। user_message, interrupt, permission_response और input_response भेजें; चैट इवेंट पाएँ, जो दोबारा कनेक्ट होने पर last_event से फिर चलाए जाते हैं।
/ws/run/{run_id}
प्लान रन के लिए एक स्ट्रीम: रनर इवेंट (task started, wave started...) और हर चाइल्ड सेशन के चैट इवेंट।

ब्राउज़र कुकी से ऑथेंटिकेट करते हैं, या POST /auth/ws-ticket से मिले एक बार के टिकट से, जिसे ticket पैरामीटर में दिया जाता है।

एक /ws/events संदेश

/ws/events?entity_types=plan,task&project_id=<uuid>

{  "entity_type": "task",  "action": "status_changed",  "entity_id": "<uuid>",  "payload": { "old_status": "pending", "new_status": "in_progress" },  "timestamp": "2026-10-05T10:00:00Z",  "project_id": "<uuid>"}

बढ़ाएँ

PO को अपना बनाने के तीन तरीके

तीनों एक ही MCP टूल से उपलब्ध हैं।

प्रोटोकॉल
स्टेट और ट्रांज़िशन के साथ एक फ़ाइनाइट स्टेट मशीन तय करें, रन शुरू करें, और असिस्टेंट को protocol टूल से उसे आगे बढ़ाने दें।
स्किल
स्किल नोट और कोड के समूह हैं जो इस्तेमाल से उभरते हैं; skill टूल उन्हें सक्रिय करता है, और प्रोजेक्ट व इंस्टेंस के बीच एक्सपोर्ट और इंपोर्ट करता है।
MCP फ़ेडरेशन
mcp_federation बाहरी MCP सर्वर को stdio, sse या streamable_http पर जोड़ता है, ताकि उनके टूल PO से पहुँच में हों।