# 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](remote-mcp.md) 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.

```sh
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.

```text
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`.

```json
{
  "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.

```json
{"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.

```sh
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](reference.md) · [Create an instance](deployments.md)