Zum Inhalt springen

Für Entwickler

Schließe deine Agenten an denselben Graphen an wie deine Pläne

Project Orchestrator stellt alles, was die App tut, als MCP-Werkzeuge, REST-API und zwei WebSocket-Streams bereit. Ein Rust-Server hält Code, Pläne, Entscheidungen und Notizen in einem Neo4j-Graphen und in Meilisearch.

MCP-Werkzeuge
33
MCP-Werkzeuge
Aktionen insgesamt
426
Aktionen insgesamt
Sprachen geparst
17
Sprachen geparst
WebSocket-Streams
4
WebSocket-Streams

Du suchst das Produkt selbst? Geh zurück zur Startseite.

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

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

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

Verbinden

PO an einen MCP-Client anschließen

Die Desktop-App oder der Server muss laufen. Dann registriert ein Befehl PO in Claude Code, oder du fügst den Eintrag für jeden anderen MCP-Client von Hand hinzu.

Den Server installieren und starten

Der Server braucht Neo4j und Meilisearch. NATS ist optional. Das Repository liefert eine docker-compose.yml für alle drei.

orchestrator serve

# needs Neo4j and Meilisearch: docker compose up -dbrew install this-rs/tap/project-orchestratororchestrator serve --port 8080

PO in Claude Code registrieren

Das schreibt den MCP-Eintrag im stdio-Modus, mit dieser Server-URL und ihrem Auth-Secret, und gibt die Werkzeuge vorab frei.

orchestrator setup-claude

orchestrator setup-claude --port 8080

setup-claude fügt außerdem mcp__project-orchestrator__* zu den erlaubten Werkzeugen in ~/.claude/settings.json hinzu, damit Claude Code nicht vor jedem Aufruf nachfragt.

Prüfen, ob es funktioniert

Führe in Claude Code /mcp aus: project-orchestrator sollte aufgelistet sein. Frag dann nach der Liste der Projekte: Claude ruft project(action: "list") auf.

Claude Code

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

Jeder MCP-Client, stdio

mcp_server ist ein dünner Proxy: Er spricht MCP über stdio und leitet jeden Aufruf an die REST-API weiter. Er verbindet sich selbst nie mit Neo4j. Setze PO_AUTH_TOKEN, oder PO_JWT_SECRET, damit er beim Start ein Token erzeugt.

~/.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>"      }    }  }}

Probiere: wechsle zwischen stdio, Claude Code und einer rohen HTTP-Anfrage, und kopiere dann den Block

MCP-Werkzeuge

33 Werkzeuge, eine Aufrufform

Jedes Werkzeug nimmt einen action-Parameter und leitet an genau eine Operation weiter. Suche nach Werkzeug, Aktion oder Parameter und kopiere dann den genauen Aufruf.

33 Werkzeuge

plan

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

Planung und Umsetzung 27 aktionen

Beispielaufruf

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

Aktionen

+21 weitere
Alle Beispiele (4)

Parameter

plan_idproject_idtitledescriptionpriorityconstraintsstatussearchlimitoffsetsort_bysort_orderpriority_minpriority_maxcwdproject_slugtrigger_idtrigger_typeconfigcooldown_secsrun_idrun_idstask_idparent_session_idcustom_sectionsprovidermodeltask_class

Probiere: suche ein Werkzeug, nutze die Pfeiltasten in der Liste, öffne die Beispiele und kopiere jeden Aufruf

Argumentwerte wie <uuid> sind Platzhalter. Die Namen von Aktionen und Parametern sind aus dem Quellcode des Servers gelesen.

Architektur

Ein Rust-Server, drei Speicher, beliebige Clients

Clients berühren die Datenbanken nie. Sie sprechen mit dem Server, der Code parst, die API bereitstellt und Ereignisse streamt.

Wähle eine Komponente, um ihre Rolle und die Abläufe zu sehen, die sie erreichen, oder verfolge eine Werkzeuganfrage durch das System.

Probiere: fahre über eine Komponente oder wähle sie aus, oder folge einer Anfrage Schritt für Schritt

Wie sie miteinander sprechen

  • 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

Code-Parsing

17 Sprachen, geparst mit tree-sitter

Jede Datei wird in Funktionen, Structs, Traits, Enums, Importe, impl-Blöcke und Aufrufkanten zerlegt und dann im Graphen gespeichert.

17 Sprachen

Fahre über eine Sprache, fokussiere oder tippe sie an, um zu sehen, welche Arten von Symbolen PO daraus extrahiert.

Probiere: fahre über eine Sprache oder tippe sie an

Pro Datei: Funktionen, Structs, Traits, Enums, Importe, impl-Blöcke, Funktionsaufrufe mit einem Konfidenzwert.

JavaScript-Dateien (.js, .jsx, .mjs, .cjs) werden mit der TypeScript-Grammatik gelesen.

API und Ereignisse

REST für den Zustand, WebSockets für Änderungen

Pläne, Code, Notizen und der Rest sind schlichtes JSON über HTTP. Änderungen werden über WebSockets gepusht.

Wichtigste REST-Endpunkte

Die meisten Routen liegen hinter der Auth-Middleware. Ist kein Auth-Abschnitt konfiguriert, ist die API offen.

GET/healthLiveness
GET/api/versionServer version
GET/api/projectsList projects (POST creates)
POST/api/projects/{slug}/syncParse a project into the graph
GET/api/plans/{plan_id}/wavesParallel waves of a plan
POST/api/plans/{plan_id}/runStart the runner on a plan
GET/api/code/searchSearch code
GET/api/code/impactImpact analysis
GET/api/notes/searchSearch notes
GET/api/decisions/searchSearch decisions
POST/api/reasonReasoning over the graph
POST/mcpMCP over Streamable HTTP

WebSocket-Streams

  • /ws/events

    Jedes Anlegen, Aktualisieren, Löschen, Verknüpfen, Lösen und jede Statusänderung, als ein JSON-Ereignis. Filtere mit den Query-Parametern entity_types, project_id und layers.

  • /ws/chat/{session_id}

    Unterhaltung mit dem Assistenten. Sende user_message, interrupt, permission_response, input_response, set_permission_mode und set_model (das Modell wechselt sofort oder beim nächsten Fortsetzen, wenn die Sitzung ruht); empfange die Chat-Ereignisse, die nach einer Wiederverbindung ab last_event erneut abgespielt werden.

  • /ws/run/{run_id}

    Ein Stream für einen Plan-Lauf: Runner-Ereignisse (Aufgabe gestartet, Welle gestartet...) plus die Chat-Ereignisse jeder Kind-Sitzung.

Browser authentifizieren sich mit einem Cookie oder mit einem Einmal-Ticket von POST /auth/ws-ticket, das als Parameter ticket übergeben wird.

Live-Ereignisstrom, Beispiel

Die Form ist die echte (CrudEvent auf /ws/events). Die Ereignisse selbst sind für diese Darstellung erfunden.

10 Ereignisse angezeigt, 10 empfangen

Eine /ws/events-Nachricht

/ws/events

{  "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>"}

Probiere: filtere nach Typ, pausiere den Strom, wähle ein Ereignis, um seine Nachricht zu sehen

Erweitern

Drei Wege, PO zu deinem zu machen

Alle drei sind über dieselben MCP-Werkzeuge verfügbar.

  • Protokolle

    Definiere einen endlichen Automaten mit Zuständen und Übergängen, starte einen Lauf und lass Agenten ihn mit dem Werkzeug protocol voranbringen.

  • Skills

    Skills sind Cluster aus Notizen und Code, die durch Nutzung entstehen; das Werkzeug skill aktiviert, exportiert und importiert sie über Projekte und Instanzen hinweg.

  • MCP-Föderation

    mcp_federation verbindet externe MCP-Server über stdio, sse oder streamable_http, sodass ihre Werkzeuge über PO erreichbar sind.

Mitmachen

Eine Idee oder einen Bug gefunden? Sag es uns.

Project Orchestrator ist Open Source. Ideen und Fehlerberichte werden beide als Issues auf GitHub eröffnet, wo sie jeder lesen kann.

Eine Funktion anfragen

Beschreib das Problem, das gelöst werden soll, und was du heute tust, um es zu umgehen. Ein klar beschriebenes Problem lässt sich leichter besprechen als eine fertige Lösung.

Sie wird als öffentlicher Issue auf GitHub eröffnet, wo die Maintainer und andere Nutzer sie lesen und ergänzen können.

Einen Bug melden

Sag uns, was du getan hast, was du erwartet hast und was stattdessen passiert ist. Je genauer die Schritte, desto leichter lässt sich das Problem nachstellen.

Er wird als öffentlicher Issue auf GitHub eröffnet, wo die Maintainer und andere Nutzer ihn lesen und ergänzen können.

Ein guter Bericht enthält

  • Die Version von Project Orchestrator, die du nutzt, zum Beispiel den Tag eines Releases auf der Seite Releases.
  • Dein Betriebssystem und dessen Version.
  • Die Schritte, die zum Problem führen, in der richtigen Reihenfolge, und was du stattdessen erwartet hast.
  • Die genaue Fehlermeldung oder ein Screenshot, falls vorhanden.