dragdropdo

MCP de conversión de archivos de alto rendimiento y sin límites

Ver en dragdropdo.comPrueba este MCPPatrocinado

Documentación

Clientes MCP (Claude Code, Cursor, personalizados)

Conecta asistentes de IA y aplicaciones a DragDropDo usando el Protocolo de Contexto de Modelos (MCP) sobre HTTPS.

Servidor MCP de DragDropDo

El servidor MCP de DragDropDo expone las mismas capacidades que la API de Negocio—subir, convertir, comprimir, fusionar, comprimir en ZIP, herramientas de contraseña PDF y sondeo de estado—como herramientas MCP. Los clientes se conectan a través de HTTP Streamable (HTTPS).

Requisitos previos

  • Una clave API D3 desde el panel (iniciar sesión → Cuenta → generar clave API). La misma clave que para Authorization: Bearer en /api/v1.
  • URL MCP: https://mcp.dragdropdo.com/mcp

Envía la clave API en cada solicitud MCP en el encabezado Authorization:

Authorization: Bearer <YOUR_D3_API_KEY>

El servidor valida esta clave de la misma manera que las solicitudes REST (consulta Autenticación).

Claude Code

Claude Code admite servidores MCP remotos a través de HTTP. Prefiere --transport http (SSE está obsoleto).

CLI (recomendado)

Agrega el servidor y pasa tu clave API en el encabezado Authorization:

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

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

Ámbitos: agrega --scope project para almacenar la entrada en el .mcp.json del proyecto, o --scope user para tu configuración de usuario. Consulta Conecta Claude Code a herramientas a través de MCP.

Configuración JSON

Claude Code fusiona entradas MCP desde ~/.claude.json y, para el ámbito del proyecto, .mcp.json. Una entrada de servidor HTTP se ve así (la estructura puede variar ligeramente según la versión de Claude Code—usa claude mcp get <name> después de agregarla para ver la forma exacta):

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

Puedes usar sustitución de variables de entorno en los valores donde tu herramienta lo admita (por ejemplo Bearer ${D3_API_KEY}), para que los secretos no se confirmen en git.

Cursor

En Cursor, los servidores MCP se definen en el archivo de configuración MCP (a menudo usuario: ~/.cursor/mcp.json, o proyecto .cursor/mcp.json según tu configuración).

Agrega una entrada con url y headers:

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

Reinicia Cursor o recarga los servidores MCP para que se detecte el nuevo servidor. El asistente podrá entonces llamar a las herramientas de DragDropDo (por ejemplo initiate_upload, convert_file, poll_status) cuando sea apropiado.

Clientes MCP personalizados

Usa un cliente oficial del Protocolo de Contexto de Modelos con HTTP Streamable para https://mcp.dragdropdo.com/mcp, autenticado con Authorization: Bearer y tu clave API.

Los ejemplos a continuación inicializan la sesión y listan herramientas. Ajusta las importaciones y APIs a la versión de tu 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();

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

Herramientas disponibles (resumen)

Los nombres típicos de herramientas incluyen: 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. El servidor también envía instrucciones que describen el flujo de trabajo de subida y operación. Usa list_tools desde tu cliente después de conectarte para ver la lista canónica y los esquemas de tu sesión.

Documentación relacionada