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

const url = new URL("https://mcp.dragdropdo.com/mcp");
const transport = new StreamableHTTPClientTransport(url, {
  authProvider: {
    token: async () => process.env.D3_API_KEY!,
  },
});

const client = new Client({ name: "my-app", version: "1.0.0" });
await client.connect(transport);
await client.listTools();
// await client.callTool({ name: "supported_operation", arguments: { ext: "pdf" } });

import os
import httpx
from mcp import ClientSession
from mcp.client.streamable_http import streamable_http_client

URL = "https://mcp.dragdropdo.com/mcp"
api_key = os.environ["D3_API_KEY"]
headers = {"Authorization": f"Bearer {api_key}"}

async def main():
    async with httpx.AsyncClient(headers=headers) as http_client:
        async with streamable_http_client(URL, http_client=http_client) as (read, write):
            async with ClientSession(read, write) as session:
                await session.initialize()
                await session.list_tools()
                # await session.call_tool("supported_operation", {"ext": "pdf"})

# asyncio.run(main())

<?php

declare(strict_types=1);

use Mcp\Client;
use Mcp\Client\Transport\HttpTransport;

$apiKey = getenv('D3_API_KEY') ?: '';

$client = Client::builder()
    ->setClientInfo('My App', '1.0.0')
    ->build();

$transport = new HttpTransport(
    endpoint: 'https://mcp.dragdropdo.com/mcp',
    headers: ['Authorization' => 'Bearer ' . $apiKey],
);

$client->connect($transport);
$client->listTools();
// $client->callTool(name: 'supported_operation', arguments: ['ext' => 'pdf']);
$client->disconnect();

# Gemfile: gem "mcp" / gem "faraday", ">= 2.0"

require "mcp"

http_transport = MCP::Client::HTTP.new(
  url: "https://mcp.dragdropdo.com/mcp",
  headers: {
    "Authorization" => "Bearer #{ENV.fetch('D3_API_KEY')}",
  },
)

client = MCP::Client.new(transport: http_transport)
client.tools
# client.call_tool(tool: client.tools.first, arguments: { "ext" => "pdf" })

package main

import (
	"context"
	"os"

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

func main() {
	ctx := context.Background()
	key := os.Getenv("D3_API_KEY")

	httpTransport, err := transport.NewStreamableHTTP(
		"https://mcp.dragdropdo.com/mcp",
		transport.WithHTTPHeaders(map[string]string{
			"Authorization": "Bearer " + key,
		}),
	)
	if err != nil {
		panic(err)
	}

	c := client.NewClient(httpTransport)
	defer c.Close()

	if err := c.Initialize(ctx); err != nil {
		panic(err)
	}
	if _, err := c.ListTools(ctx, mcp.ListToolsRequest{}); err != nil {
		panic(err)
	}
	// c.CallTool(ctx, mcp.CallToolRequest{ ... })
}

import io.modelcontextprotocol.sdk.client.McpClient;
import io.modelcontextprotocol.sdk.client.McpSyncClient;
import io.modelcontextprotocol.sdk.client.transport.HttpClientStreamableHttpTransport;
import io.modelcontextprotocol.sdk.spec.McpTransport;

// io.modelcontextprotocol.sdk:mcp — use your BOM or version from https://java.sdk.modelcontextprotocol.io/

String apiKey = System.getenv("D3_API_KEY");
McpTransport transport = HttpClientStreamableHttpTransport.builder("https://mcp.dragdropdo.com")
    .endpoint("/mcp")
    .requestCustomizer(req -> req.header("Authorization", "Bearer " + apiKey))
    .build();

McpSyncClient client = McpClient.sync(transport).build();
client.initialize();
client.listTools();
// client.callTool(new CallToolRequest("supported_operation", Map.of("ext", "pdf")));
client.closeGracefully();