Aller au contenu

Pour les développeurs

Branche tes agents sur le même graphe que tes plans

Project Orchestrator expose tout ce que fait l’app sous forme d’outils MCP, d’une API REST et de deux flux WebSocket. Un serveur Rust garde le code, les plans, les décisions et les notes dans un graphe Neo4j et dans Meilisearch.

outils MCP
33
outils MCP
actions au total
426
actions au total
langages analysés
17
langages analysés
flux WebSocket
4
flux WebSocket

Tu cherches le produit lui-même ? Retourne à la page d’accueil.

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

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

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

Connexion

Branche PO sur un client MCP

L’app de bureau ou le serveur doit tourner. Ensuite, une commande enregistre PO dans Claude Code, ou tu ajoutes l’entrée à la main pour tout autre client MCP.

Installer et démarrer le serveur

Le serveur a besoin de Neo4j et de Meilisearch. NATS est optionnel. Le dépôt fournit un docker-compose.yml pour les trois.

orchestrator serve

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

Enregistrer PO dans Claude Code

Cette commande écrit l’entrée MCP en mode stdio, avec l’URL de ce serveur et son secret d’authentification, et pré-approuve les outils.

orchestrator setup-claude

orchestrator setup-claude --port 8080

setup-claude ajoute aussi mcp__project-orchestrator__* aux outils autorisés de ~/.claude/settings.json, pour que Claude Code ne demande pas confirmation à chaque appel.

Vérifier que ça marche

Dans Claude Code, lance /mcp : project-orchestrator doit apparaître dans la liste. Demande ensuite la liste des projets : Claude appelle project(action: "list").

Claude Code

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

Tout client MCP, en stdio

mcp_server est un proxy léger : il parle MCP sur stdio et transmet chaque appel à l’API REST. Il ne se connecte jamais lui-même à Neo4j. Définis PO_AUTH_TOKEN, ou PO_JWT_SECRET pour qu’il génère un jeton au démarrage.

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

Essaie : passe de stdio à Claude Code puis à une requête HTTP brute, et copie le bloc

Outils MCP

33 outils, une seule forme d’appel

Chaque outil prend un paramètre action et l’aiguille vers une opération. Cherche par outil, action ou paramètre, puis copie l’appel exact.

33 outils

plan

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

Planification et livraison 27 actions

Exemple d’appel

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

Actions

+21 autres
Tous les exemples (4)

Paramètres

plan_idproject_idtitledescriptionpriorityconstraintsstatussearchlimitoffsetsort_bysort_orderpriority_minpriority_maxcwdproject_slugtrigger_idtrigger_typeconfigcooldown_secsrun_idrun_idstask_idparent_session_idcustom_sectionsprovidermodeltask_class

Essaie : cherche un outil, parcours la liste aux flèches, ouvre les exemples et copie un appel

Les valeurs d’arguments comme <uuid> sont des espaces réservés. Les noms d’actions et de paramètres sont lus dans le code source du serveur.

Architecture

Un serveur Rust, trois stockages, n’importe quel client

Les clients ne touchent jamais aux bases de données. Ils parlent au serveur, qui analyse le code, sert l’API et diffuse les événements.

Choisis un composant pour voir son rôle et les flux qui l’atteignent, ou suis une requête d’outil à travers le système.

Essaie : survole ou choisis un composant, ou suis une requête pas à pas

Comment ils communiquent

  • 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

Analyse du code

17 langages, analysés avec tree-sitter

Chaque fichier est analysé en fonctions, structs, traits, enums, imports, blocs impl et arêtes d’appel, puis stocké dans le graphe.

17 langages

Survole, focalise ou touche un langage pour voir le genre de symboles que PO en extrait.

Essaie : survole ou touche un langage

Par fichier : fonctions, structs, traits, enums, imports, blocs impl, appels de fonctions avec un score de confiance.

Les fichiers JavaScript (.js, .jsx, .mjs, .cjs) sont lus avec la grammaire TypeScript.

API et événements

REST pour l’état, WebSocket pour les changements

Plans, code, notes et le reste passent en JSON simple sur HTTP. Les changements sont poussés sur des WebSocket.

Principaux endpoints REST

La plupart des routes sont derrière le middleware d’authentification. Quand aucune section d’authentification n’est configurée, l’API est ouverte.

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

Flux WebSocket

  • /ws/events

    Chaque création, mise à jour, suppression, liaison, déliaison et changement de statut, sous forme d’un événement JSON. Filtre avec les paramètres de requête entity_types, project_id et layers.

  • /ws/chat/{session_id}

    Conversation avec l’assistant. Envoie user_message, interrupt, permission_response, input_response, set_permission_mode et set_model (le modèle change en direct, ou à la prochaine reprise si la session est inactive) ; reçois les événements de chat, rejoués depuis last_event après une reconnexion.

  • /ws/run/{run_id}

    Un seul flux pour l’exécution d’un plan : les événements de l’exécuteur (tâche démarrée, vague démarrée...) plus les événements de chat de chaque session enfant.

Les navigateurs s’authentifient avec un cookie, ou avec un ticket à usage unique obtenu via POST /auth/ws-ticket et passé dans le paramètre ticket.

Flux d’événements en direct, exemple

La forme est la vraie (CrudEvent sur /ws/events). Les événements eux-mêmes sont inventés pour cette illustration.

10 événements affichés, 10 reçus

Un message /ws/events

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

Essaie : filtre par type, mets le flux en pause, choisis un événement pour voir son message

Étendre

Trois façons de faire de PO ton outil

Les trois sont accessibles par les mêmes outils MCP.

  • Protocoles

    Définis une machine à états finis avec ses états et ses transitions, lance une exécution, et laisse les agents la faire avancer avec l’outil protocol.

  • Skills

    Les skills sont des groupes de notes et de code qui émergent à l’usage ; l’outil skill les active, les exporte et les importe entre projets et instances.

  • Fédération MCP

    mcp_federation connecte des serveurs MCP externes en stdio, sse ou streamable_http, pour que leurs outils soient accessibles via PO.

Contribuer

Une idée, ou un bug ? Dis-le-nous.

Project Orchestrator est open source. Les idées comme les bugs s’ouvrent en issue sur GitHub, où tout le monde peut les lire.

Demander une fonctionnalité

Décris le problème que tu veux résoudre, et ce que tu fais aujourd’hui pour le contourner. Un problème clair se discute plus facilement qu’une solution toute faite.

Ta demande s’ouvre en issue publique sur GitHub, où les mainteneurs et les autres utilisateurs peuvent la lire et la compléter.

Signaler un bug

Dis-nous ce que tu as fait, ce que tu attendais et ce qui s’est passé à la place. Plus les étapes sont précises, plus le problème est facile à reproduire.

Ton signalement s’ouvre en issue publique sur GitHub, où les mainteneurs et les autres utilisateurs peuvent le lire et le compléter.

Un bon rapport contient

  • La version de Project Orchestrator que tu utilises, par exemple le tag d’une version de la page Versions.
  • Ton système d’exploitation et sa version.
  • Les étapes qui mènent au problème, dans l’ordre, et ce que tu attendais à la place.
  • Le message d’erreur exact ou une capture d’écran, s’il y en a une.