Authentication

curl -X POST http://localhost:9090/mcp \
  -H "Authorization: Bearer $KUBEMQ_MCP_AUTH_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

using ModelContextProtocol.Client;

var url = Environment.GetEnvironmentVariable("KUBEMQ_MCP_URL") ?? "http://localhost:9090";
var token = Environment.GetEnvironmentVariable("KUBEMQ_MCP_AUTH_TOKEN");

var transport = new HttpClientTransport(new HttpClientTransportOptions
{
    Endpoint = new Uri($"{url}/mcp"),
    AdditionalHeaders = new Dictionary<string, string>
    {
        ["Authorization"] = $"Bearer {token}",
    },
});
await using var client = await McpClientFactory.CreateAsync(transport);

var tools = await client.ListToolsAsync();
Console.WriteLine($"Tools: {tools.Count}");

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/mark3labs/mcp-go/client"
	"github.com/mark3labs/mcp-go/client/transport"
	"github.com/mark3labs/mcp-go/mcp"
)

func main() {
	url := os.Getenv("KUBEMQ_MCP_URL")
	if url == "" {
		url = "http://localhost:9090"
	}
	token := os.Getenv("KUBEMQ_MCP_AUTH_TOKEN")

	c, err := client.NewStreamableHttpClient(url+"/mcp",
		transport.WithHTTPHeaders(map[string]string{
			"Authorization": "Bearer " + token,
		}),
	)
	if err != nil {
		log.Fatal(err)
	}
	defer c.Close()

	ctx := context.Background()
	if err := c.Start(ctx); err != nil {
		log.Fatal(err)
	}
	if _, err := c.Initialize(ctx, mcp.InitializeRequest{}); err != nil {
		log.Fatal(err)
	}

	tools, err := c.ListTools(ctx, mcp.ListToolsRequest{})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Tools: %d\n", len(tools.Tools))
}

import io.modelcontextprotocol.sdk.McpClient;
import io.modelcontextprotocol.sdk.client.transport.HttpClientStreamableHttpTransport;

public class Auth {
    public static void main(String[] args) {
        String url = System.getenv().getOrDefault("KUBEMQ_MCP_URL", "http://localhost:9090");
        String token = System.getenv("KUBEMQ_MCP_AUTH_TOKEN");

        var transport = HttpClientStreamableHttpTransport.builder(url)
            .endpoint("/mcp")
            .httpRequestCustomizer((builder, method, endpoint, body, context) ->
                builder.header("Authorization", "Bearer " + token))
            .build();
        var client = McpClient.sync(transport).build();
        client.initialize();

        var tools = client.listTools();
        System.out.println("Tools: " + tools.tools().size());

        client.closeGracefully();
    }
}

import io.modelcontextprotocol.kotlin.sdk.Implementation
import io.modelcontextprotocol.kotlin.sdk.client.Client
import io.modelcontextprotocol.kotlin.sdk.client.StreamableHttpClientTransport
import io.ktor.client.*
import io.ktor.client.plugins.*
import io.ktor.client.plugins.sse.*
import io.ktor.client.request.*
import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
    val url = System.getenv("KUBEMQ_MCP_URL") ?: "http://localhost:9090"
    val token = System.getenv("KUBEMQ_MCP_AUTH_TOKEN")

    val httpClient = HttpClient {
        install(SSE)
        defaultRequest { header("Authorization", "Bearer $token") }
    }
    val transport = StreamableHttpClientTransport(client = httpClient, url = "$url/mcp")
    val client = Client(clientInfo = Implementation(name = "kubemq-mcp-kotlin-example", version = "1.0.0"))
    client.connect(transport)

    val tools = client.listTools()
    println("Tools: ${tools?.tools?.size}")
}

import asyncio
import os

from mcp.client.streamable_http import streamablehttp_client
from mcp import ClientSession

KUBEMQ_MCP_URL = os.environ.get("KUBEMQ_MCP_URL", "http://localhost:9090")
TOKEN = os.environ.get("KUBEMQ_MCP_AUTH_TOKEN")


async def main():
    headers = {"Authorization": f"Bearer {TOKEN}"} if TOKEN else None
    async with streamablehttp_client(f"{KUBEMQ_MCP_URL}/mcp", headers=headers) as (read, write, _):
        async with ClientSession(read, write) as session:
            await session.initialize()
            tools = await session.list_tools()
            print(f"Tools: {len(tools.tools)}")


if __name__ == "__main__":
    asyncio.run(main())

require "mcp"

url = ENV.fetch("KUBEMQ_MCP_URL", "http://localhost:9090")
token = ENV["KUBEMQ_MCP_AUTH_TOKEN"]

client = MCP::Client.new(
  transport: MCP::Transport::StreamableHTTP.new(
    "#{url}/mcp",
    headers: { "Authorization" => "Bearer #{token}" }
  ),
  name: "kubemq-mcp-ruby-example",
  version: "1.0.0"
)
client.initialize_handshake

tools = client.list_tools
puts "Tools: #{tools.size}"

client.close

use rmcp::transport::streamable_http::StreamableHttpClientTransport;
use rmcp::transport::streamable_http::client::StreamableHttpClientTransportConfig;
use rmcp::service::RunService;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let url = std::env::var("KUBEMQ_MCP_URL")
        .unwrap_or_else(|_| "http://localhost:9090".to_string());
    let token = std::env::var("KUBEMQ_MCP_AUTH_TOKEN").unwrap_or_default();

    let http = reqwest::Client::builder()
        .default_headers({
            let mut h = reqwest::header::HeaderMap::new();
            h.insert(
                reqwest::header::AUTHORIZATION,
                format!("Bearer {token}").parse()?,
            );
            h
        })
        .build()?;

    let transport = StreamableHttpClientTransport::with_client(
        http,
        StreamableHttpClientTransportConfig::with_uri(format!("{url}/mcp")),
    );
    let client = ().serve(transport).await?;

    let tools = client.list_all_tools().await?;
    println!("Tools: {}", tools.len());
    Ok(())
}

import Foundation
import MCP

@main
struct Auth {
    static func main() async throws {
        let url = ProcessInfo.processInfo.environment["KUBEMQ_MCP_URL"] ?? "http://localhost:9090"
        let token = ProcessInfo.processInfo.environment["KUBEMQ_MCP_AUTH_TOKEN"] ?? ""

        let transport = HTTPClientTransport(
            endpoint: URL(string: "\(url)/mcp")!,
            streaming: true,
            requestModifier: { request in
                var modified = request
                modified.addValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
                return modified
            }
        )
        let client = Client(name: "kubemq-mcp-swift-example", version: "1.0.0")
        try await client.connect(transport: transport)

        let (tools, _) = try await client.listTools()
        print("Tools: \(tools.count)")
    }
}

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const KUBEMQ_MCP_URL = process.env.KUBEMQ_MCP_URL || "http://localhost:9090";
const token = process.env.KUBEMQ_MCP_AUTH_TOKEN;

const transport = new StreamableHTTPClientTransport(
  new URL(`${KUBEMQ_MCP_URL}/mcp`),
  {
    requestInit: {
      headers: { Authorization: `Bearer ${token}` },
    },
  }
);
const client = new Client({ name: "kubemq-mcp-ts-example", version: "1.0.0" });
await client.connect(transport);

const tools = await client.listTools();
console.log(`Tools: ${tools.tools.length}`);

await client.close();