dragdropdo

MCP de Conversão de Arquivos Ilimitada e de Alto Desempenho

Ver em dragdropdo.comExperimente este MCPPatrocinado

Documentação

Clientes MCP (Claude Code, Cursor, personalizados)

Conecte assistentes de IA e aplicativos ao DragDropDo usando o Model Context Protocol (MCP) via HTTPS.

Servidor MCP DragDropDo

O servidor MCP DragDropDo expõe as mesmas capacidades da Business API—upload, conversão, compressão, mesclagem, zip, ferramentas de senha de PDF e consulta de status—como ferramentas MCP. Os clientes se conectam via Streamable HTTP (HTTPS).

Pré-requisitos

  • Uma chave de API D3 do painel (entrar → Conta → gerar chave de API). A mesma chave usada para Authorization: Bearer em /api/v1.
  • URL MCP: https://mcp.dragdropdo.com/mcp

Envie a chave de API em cada solicitação MCP no cabeçalho Authorization:

Authorization: Bearer <YOUR_D3_API_KEY>

O servidor valida essa chave da mesma forma que as solicitações REST (veja Autenticação).

Claude Code

Claude Code suporta servidores MCP remotos via HTTP. Prefira --transport http (SSE está obsoleto).

CLI (recomendado)

Adicione o servidor e passe sua chave de API no cabeçalho Authorization:

claude mcp add --transport http d3 https://mcp.dragdropdo.com/mcp \
  --header "Authorization: Bearer YOUR_D3_API_KEY"

Comandos úteis: claude mcp list, claude mcp get d3, claude mcp remove d3.

Escopos: adicione --scope project para armazenar a entrada no .mcp.json do projeto, ou --scope user para a configuração do usuário. Veja Conectar Claude Code a ferramentas via MCP.

Configuração JSON

O Claude Code mescla entradas MCP de ~/.claude.json e, para escopo de projeto, .mcp.json. Uma entrada de servidor HTTP se parece com isto (a estrutura pode variar ligeiramente conforme a versão do Claude Code—use claude mcp get <name> após adicionar para ver a forma exata):

{
  "mcpServers": {
    "d3": {
      "type": "http",
      "url": "https://mcp.dragdropdo.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_D3_API_KEY"
      }
    }
  }
}

Você pode usar substituição de ambiente em valores onde sua ferramenta suporta (por exemplo Bearer ${D3_API_KEY}), para que segredos não sejam commitados no git.

Cursor

No Cursor, os servidores MCP são definidos no arquivo de configuração MCP (geralmente usuário: ~/.cursor/mcp.json, ou projeto .cursor/mcp.json dependendo da sua configuração).

Adicione uma entrada com url e headers:

{
  "mcpServers": {
    "d3": {
      "url": "https://mcp.dragdropdo.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_D3_API_KEY"
      }
    }
  }
}

Reinicie o Cursor ou recarregue os servidores MCP para que o novo servidor seja detectado. O assistente pode então chamar as ferramentas do DragDropDo (por exemplo initiate_upload, convert_file, poll_status) quando apropriado.

Clientes MCP personalizados

Use um cliente oficial do Model Context Protocol com Streamable HTTP para https://mcp.dragdropdo.com/mcp, autenticado com Authorization: Bearer e sua chave de API.

Os exemplos abaixo inicializam a sessão e listam ferramentas. Ajuste imports e APIs à versão do seu SDK.

```ts NODE theme={null} 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" } });


```python PYTHON theme={null}
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();

Referências de SDK: TypeScript, Python, PHP mcp/sdk, Ruby mcp gem, Go mark3labs/mcp-go, Java io.modelcontextprotocol.sdk:mcp.

Ferramentas disponíveis (resumo)

Nomes típicos de ferramentas incluem: initiate_upload, complete_upload, supported_operation, convert_file, compress_file, merge_files, zip_files, lock_pdf, unlock_pdf, reset_pdf_password, get_status, poll_status, get_download_link. O servidor também envia instruções descrevendo o fluxo de upload e operação. Use list_tools do seu cliente após conectar para ver a lista canônica e os esquemas da sua sessão.

Documentação relacionada