Connect to the Hub

Public hosted pilot

Use https://daedro.hub.rokenshi.com/workspace#account in a browser. Sign in with Google and complete authenticator verification. The marketplace and authenticated browser workflows are hosted on this origin.

The public discovery API is GET https://daedro.hub.rokenshi.com/api/v1/services. It describes catalog entries and their actual available_here status. It does not grant permission to execute a tool.

The hosted Hub exposes one authenticated remote MCP endpoint: https://daedro.hub.rokenshi.com/mcp. Connect with a Streamable HTTP client supporting OAuth authorization with S256 PKCE. Google sign-in and Authenticator verification happen in the browser; access is scoped to your account and selected profile and can be revoked in Account. See Connect an AI client for setup, supported tools and pilot limitations.

The examples below describe the separate local discovery/managed portal binary, not the public shared pilot. Its localhost addresses do not point to the cloud server. OpenBao has no public endpoint; applications use the private Secret boundary.

Local portal only

Retrieve a service card over HTTP, then call the same discovery operation through MCP. Your destination changes when you move from discovering a tool to invoking a deployed instance.

Read a service card over HTTP

From another terminal, list the services and retrieve one by its exact ID. The list returns an object with a services array. The second request returns one of those service objects directly.

PORTAL_URL=http://127.0.0.1:8791
curl -fsS "$PORTAL_URL/api/v1/services"
curl -fsS "$PORTAL_URL/api/v1/services/daedro-s3"

Pick a transport from protocols. The setup and auth fields explain prerequisites, while tools, endpoints and example show what to call. The deployment selector lists the built-in tools and your approved packages. Entries for other Daedro platform services describe contracts hosted by those components. A component route such as POST /v1/execute must be sent to that component’s address. Use its credentials and deployment instructions.

Connect an MCP client

For a client that supports Streamable HTTP, select that transport and the URL of the running portal.

http://127.0.0.1:8791/mcp

For stdio, first run make build. Configure the absolute path to the binary as the command and mcp as a separate argument. This starts a dedicated catalog process and works without a running HTTP server. Replace the path in this example for clients using mcpServers.

{
  "mcpServers": {
    "daedro-mcp-hub": {
      "command": "/absolute/path/to/daedro-mcp-hub/bin/daedro-mcp-hub",
      "args": ["mcp"]
    }
  }
}

The client initializes an MCP session, requests tools/list, then calls services_list with {}. Select an ID and pass it to service_get. Pass the following tools/call parameters to retrieve the S3 card.

{"name":"service_get","arguments":{"id":"daedro-s3"}}

The returned structuredContent matches the HTTP service card. Connecting to the actual S3 endpoint is a separate step. In managed mode, use the printed HTTPS URL, configure the client to trust ca.crt, and send Authorization: Bearer <token>. Administrator sessions can list and invoke management tools. Named callers can use their visible instances through instances_list, instance_create, instance_get, instance_call and instance_remove. The operator-managed cleaning pool also accepts calls through deployment_call.

Verify with the Go SDK

Leave the read-only HTTP hub running. From the repository root, paste the following block into a second terminal. It uses the official MCP SDK version pinned in go.mod. Expect the two discovery tool names and a card whose ID is daedro-s3. Set PORTAL_MCP_URL when using a different local discovery port.

EXAMPLE_DIR=$(mktemp -d)
cat > "$EXAMPLE_DIR/main.go" <<'GO'
package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "os"
    "time"

    "github.com/modelcontextprotocol/go-sdk/mcp"
)

func main() {
    endpoint := os.Getenv("PORTAL_MCP_URL")
    if endpoint == "" {
        endpoint = "http://127.0.0.1:8791/mcp"
    }
    ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
    defer cancel()
    client := mcp.NewClient(&mcp.Implementation{Name: "portal-example", Version: "1"}, nil)
    session, err := client.Connect(ctx, &mcp.StreamableClientTransport{Endpoint: endpoint}, nil)
    if err != nil { log.Fatal(err) }
    defer session.Close()
    tools, err := session.ListTools(ctx, nil)
    if err != nil { log.Fatal(err) }
    for _, tool := range tools.Tools { fmt.Println(tool.Name) }
    card, err := session.CallTool(ctx, &mcp.CallToolParams{
        Name: "service_get", Arguments: map[string]string{"id": "daedro-s3"},
    })
    if err != nil { log.Fatal(err) }
    if card.IsError { log.Fatal("service_get returned an MCP error") }
    if err := json.NewEncoder(os.Stdout).Encode(card.StructuredContent); err != nil { log.Fatal(err) }
}
GO
go run "$EXAMPLE_DIR/main.go"

Connect to the instance

Copy the HTTPS endpoint from the deployment workspace, for example https://127.0.0.1:8792/mcp/instances/INSTANCE_ID. Give the client the operator-issued CA and your bearer token in an Authorization header. On this endpoint, tools/list describes the selected profile. On a Text stats instance, call word_count with {"text":"Quarterly revenue increased."}. Expect structuredContent.word_count to be 3.

Use the live reference to look up operations the current Hub exposes to your role. Reference · Create an instance