Ir para o conteúdo

Para desenvolvedores

Conecte seus assistentes ao mesmo grafo dos seus planos

O Project Orchestrator expõe tudo o que o aplicativo faz como ferramentas MCP, uma API REST e dois fluxos WebSocket. Um servidor em Rust guarda código, planos, decisões e notas em um grafo Neo4j e no Meilisearch.

ferramentas MCP
33
ferramentas MCP
ações no total
426
ações no total
linguagens analisadas
17
linguagens analisadas
fluxos WebSocket
4
fluxos WebSocket

Procurando o produto em si? Volte à página inicial.

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

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

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

Conectar

Conecte o PO a um cliente MCP

O aplicativo para desktop ou o servidor precisa estar rodando. Depois, um comando registra o PO no Claude Code, ou você adiciona a entrada manualmente em qualquer outro cliente MCP.

Instale e inicie o servidor

O servidor precisa do Neo4j e do Meilisearch. O NATS é opcional. O repositório traz um docker-compose.yml para os três.

orchestrator serve

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

Registre o PO no Claude Code

Isto grava a entrada MCP em modo stdio, com a URL deste servidor e o seu segredo de autenticação, e pré-aprova as ferramentas.

orchestrator setup-claude

orchestrator setup-claude --port 8080

setup-claude também adiciona mcp__project-orchestrator__* às ferramentas permitidas em ~/.claude/settings.json, para o Claude Code não perguntar antes de cada chamada.

Confira se funciona

No Claude Code, execute /mcp: project-orchestrator deve aparecer na lista. Depois peça a lista de projetos: o Claude chama project(action: "list").

Claude Code

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

Qualquer cliente MCP, stdio

mcp_server é um proxy fino: ele fala MCP em stdio e encaminha cada chamada à API REST. Ele nunca se conecta ao Neo4j por conta própria. Defina PO_AUTH_TOKEN, ou PO_JWT_SECRET para que ele gere um token na inicialização.

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

Experimente: alterne entre stdio, Claude Code e uma requisição HTTP direta, depois copie o bloco

Ferramentas MCP

33 ferramentas, um só formato de chamada

Cada ferramenta recebe um parâmetro action e despacha para uma operação. Busque por ferramenta, ação ou parâmetro e depois copie a chamada exata.

33 ferramentas

plan

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

Planejamento e entrega 27 ações

Exemplo de chamada

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

Ações

+21 mais
Todos os exemplos (4)

Parâmetros

plan_idproject_idtitledescriptionpriorityconstraintsstatussearchlimitoffsetsort_bysort_orderpriority_minpriority_maxcwdproject_slugtrigger_idtrigger_typeconfigcooldown_secsrun_idrun_idstask_idparent_session_idcustom_sectionsprovidermodeltask_class

Experimente: busque uma ferramenta, use as setas na lista, abra os exemplos e copie qualquer chamada

Valores de argumentos como <uuid> são marcadores. Os nomes das ações e dos parâmetros são lidos do código-fonte do servidor.

Arquitetura

Um servidor Rust, três armazenamentos, qualquer cliente

Os clientes nunca tocam nos bancos de dados. Eles falam com o servidor, que analisa o código, serve a API e transmite eventos.

Selecione um componente para ver o papel dele e os fluxos que chegam até ele, ou acompanhe uma chamada de ferramenta pelo sistema.

Experimente: passe o cursor ou selecione um componente, ou acompanhe uma requisição passo a passo

Como eles conversam

  • 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

Análise de código

17 linguagens, analisadas com tree-sitter

Cada arquivo é analisado em funções, structs, traits, enums, imports, blocos impl e arestas de chamada, e depois guardado no grafo.

17 linguagens

Passe o cursor, dê foco ou toque em uma linguagem para ver o tipo de símbolo que o PO extrai dela.

Experimente: passe o cursor ou toque em uma linguagem

Por arquivo: funções, structs, traits, enums, imports, blocos impl, chamadas de função com uma pontuação de confiança.

Arquivos JavaScript (.js, .jsx, .mjs, .cjs) são lidos com a gramática do TypeScript.

API e eventos

REST para o estado, WebSockets para a mudança

Planos, código, notas e o resto são JSON simples sobre HTTP. As mudanças são enviadas por WebSockets.

Principais endpoints REST

A maioria das rotas fica atrás do middleware de autenticação. Quando nenhuma seção auth está configurada, a API é aberta.

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

Fluxos WebSocket

  • /ws/events

    Cada criação, atualização, exclusão, ligação, desligamento e mudança de status, como um evento JSON. Filtre com os parâmetros de consulta entity_types, project_id e layers.

  • /ws/chat/{session_id}

    Conversa com o assistente. Envia user_message, interrupt, permission_response, input_response, set_permission_mode e set_model (o modelo muda na hora, ou na próxima retomada se a sessão estiver ociosa); recebe os eventos do chat, reenviados a partir de last_event depois de uma reconexão.

  • /ws/run/{run_id}

    Um fluxo para a execução de um plano: eventos do executor (tarefa iniciada, onda iniciada...) mais os eventos de chat de cada sessão filha.

Os navegadores se autenticam com um cookie, ou com um ticket de uso único de POST /auth/ws-ticket passado como o parâmetro ticket.

Fluxo de eventos ao vivo, exemplo

O formato é o real (CrudEvent em /ws/events). Os eventos em si são inventados, só para esta ilustração.

10 eventos exibidos, 10 recebidos

Uma mensagem de /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>"}

Experimente: filtre por tipo, pause o fluxo, selecione um evento para ver a mensagem dele

Estender

Três jeitos de fazer o PO ser seu

Os três estão disponíveis pelas mesmas ferramentas MCP.

  • Protocolos

    Defina uma máquina de estados finita com estados e transições, inicie uma execução e deixe os assistentes avançá-la com a ferramenta protocol.

  • Habilidades

    Habilidades são clusters de notas e de código que emergem do uso; a ferramenta skill as ativa, exporta e importa entre projetos e instâncias.

  • Federação MCP

    mcp_federation conecta servidores MCP externos por stdio, sse ou streamable_http, para que as suas ferramentas sejam acessíveis pelo PO.

Contribuir

Teve uma ideia ou encontrou um bug? Conte para nós.

O Project Orchestrator é código aberto. Ideias e relatos de bug são abertos como issues no GitHub, onde qualquer pessoa pode lê-los.

Pedir um recurso

Descreva o problema que você quer resolver e o que você faz hoje para contorná-lo. Um problema claro é mais fácil de discutir do que uma solução pronta.

Ele é aberto como uma issue pública no GitHub, onde os mantenedores e outros usuários podem lê-lo e acrescentar informações.

Reportar um bug

Conte o que você fez, o que esperava e o que aconteceu no lugar. Quanto mais exatos forem os passos, mais fácil será reproduzir o problema.

Ele é aberto como uma issue pública no GitHub, onde os mantenedores e outros usuários podem lê-lo e acrescentar informações.

Um bom relato inclui

  • A versão do Project Orchestrator que você usa, por exemplo a tag de uma versão na página Versões.
  • Seu sistema operacional e a versão dele.
  • Os passos que levam ao problema, em ordem, e o que você esperava no lugar.
  • A mensagem de erro exata ou uma captura de tela, se houver.