mcphub_tools Servidor MCP

Herramientas de MCP con tecnología de aimcp: encuentra MCPs donde quieras. Este servidor permite buscar MCPs disponibles en el Hub de MCPs.

Protocolo abierto

Este servidor implementa el Protocolo de Contexto de Modelo (MCP) . Actúa como un servidor MCP al que pueden conectarse clientes MCP (como asistentes de IA compatibles o herramientas de desarrollo).

Related MCP server: Glama MCP Server Search

Introducción

mcphub_tools es un servidor MCP diseñado para interactuar con el Hub MCP . Su función principal es proporcionar una herramienta que permite a los usuarios buscar MCP (Protocolos/Servidores de Contexto de Modelo) registrados en el Hub mediante palabras clave.

Herramientas

Este servidor proporciona la siguiente herramienta:

search_mcp_hub

• Descripción: Busca MCP en el MCP Hub.

• Esquema de entrada:

  {
    "type": "object",
    "properties": {
      "keywords": {
        "type": "string",
        "description": "Keywords to search for MCPs"
      }
    },
    "required": ["keywords"]
  }

• Salida: Devuelve una cadena JSON que contiene los resultados de búsqueda de la API de MCP Hub.

get_mcp_info

• Descripción: Obtiene información detallada sobre un MCP específico.

• Esquema de entrada:

  {
    "type": "object",
    "properties": {
      "id": {
        "type": "string",
        "description": "MCP identifier (UUID)"
      }
    },
    "required": ["id"]
  }

• Salida: Devuelve una cadena JSON que contiene información detallada sobre el MCP especificado.

Opciones de implementación

MCP Hub admite dos formas diferentes de implementar servidores MCP:

1. Servidor MCP estándar basado en stdio

Esta es la implementación tradicional, donde el servidor MCP se comunica con los clientes mediante la entrada/salida estándar (stdio). Este enfoque es ideal para herramientas de línea de comandos independientes que se pueden integrar con clientes MCP como Claude Desktop.

La forma más fácil de utilizar la implementación basada en stdio es a través de nuestro paquete publicado:

# Using npx (recommended for most users)
npx @aimcp/tools

# Using uvx (faster startup)
uvx @aimcp/tools

2. Servidor MCP basado en HTTP

MCP Hub también ofrece una implementación basada en HTTP que permite que los asistentes de IA y otras herramientas se conecten al servidor MCP mediante HTTP. Esto se implementa en la API de MCP Hub en /api/open/v1/streamable .

El punto final HTTP está disponible en:

https://mcp.aimcp.info/api/open/v1/streamable

Uso

Prerrequisitos

• Node.js y npm (o pnpm/yarn) instalados para la implementación basada en stdio.

• Una clave API de MCP Hub ( https://www.aimcp.info ).

Cómo obtener una clave API

• Vaya a https://www.aimcp.info .

• Regístrate o inicia sesión.

• Vaya a su perfil o configuración de cuenta.

• Busque una opción para generar o recuperar su clave API.

• También puede acceder aquí para generar una clave API. NOTA: La clave API tiene un límite de 20 solicitudes por hora.

Autenticación

La API de MCP requiere autenticación con una clave API válida. Esta clave debe proporcionarse mediante:

1. Para la implementación basada en stdio: la variable de entorno MCP_HUB_API_KEY .

2. Para la implementación basada en HTTP: el encabezado Authorization como token de portador.

Authorization: Bearer YOUR_API_KEY

Integración con asistentes de IA y clientes MCP

Configuración del escritorio de Claude

Para utilizar MCP Hub con Claude Desktop:

1. Localice el archivo de configuración de Claude Desktop:

   • Ventanas: %APPDATA%\claude\config.json

   • macOS: ~/Library/Application Support/claude/config.json o ~/.config/claude/config.json

   • Linux: ~/.config/claude/config.json

2. Agregue la siguiente configuración:

{
  "mcpServers": {
    "mcp-hub": {
      "command": "npx",
      "args": ["@aimcp/tools"],
      "environment": {
        "MCP_HUB_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

3. Reinicie Claude Desktop para aplicar los cambios.

4. En tu conversación, puedes acceder a las herramientas de MCP Hub escribiendo "@mcp-hub".

Cline y otras herramientas CLI

Para herramientas basadas en línea de comandos como Cline:

1. Cree un archivo de configuración llamado servers.json en el directorio de su proyecto:

{
  "servers": [
    {
      "name": "mcp-hub-tools",
      "command": ["npx", "@aimcp/tools"],
      "environment": {
        "MCP_HUB_API_KEY": "YOUR_API_KEY"
      }
    }
  ]
}

2. Inicie la herramienta con referencia a esta configuración:

cline --mcp-servers-config ./servers.json

Para herramientas que admiten servidores MCP remotos

Algunos clientes MCP más recientes admiten conexiones HTTP directas. Configúrelos con:

{
  "mcpServers": {
    "mcp-hub-http": {
      "url": "https://mcp.aimcp.info/api/open/v1/streamable",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Para herramientas que utilizan configuración basada en archivos (cursor, etc.)

1. Crear un archivo de configuración:

{
  "mcpServers": {
    "mcp-hub": {
      "command": "npx",
      "args": ["@aimcp/tools"],
      "environment": {
        "MCP_HUB_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

2. Haga referencia a este archivo en la configuración de su herramienta o iníciela con el parámetro de configuración apropiado.

Ejecutar manualmente

También puede ejecutar el servidor basado en stdio manualmente para realizar pruebas (asegúrese de que MCP_HUB_API_KEY esté configurado en su entorno):

export MCP_HUB_API_KEY="YOUR_API_KEY_HERE"
npx @aimcp/tools

Interfaz API

Este servidor interactúa con el siguiente punto final de la API de MCP Hub:

• Punto final: GET https://www.aimcp.info/api/open/v1/search

• Autenticación: requiere un token de portador en el encabezado Authorization , utilizando MCP_HUB_API_KEY .

• Parámetro de consulta: keywords (cadena)

Uso de la API MCP basada en HTTP

MCP Hub proporciona un servidor MCP basado en HTTP en /api/open/v1/streamable que implementa el Protocolo de Contexto de Modelo. Esto permite que los asistentes y herramientas de IA busquen MCP y recuperen información directamente.

Pasos de conexión

1. Primero, establezca una conexión para obtener un ID de sesión:

GET /api/open/v1/streamable
Authorization: Bearer YOUR_API_KEY

Respuesta:

{
  "success": true,
  "sessionId": "194830ab-eb0b-4d17-a574-af96705276c2",
  "message": "Connection established. Use this sessionId for subsequent calls."
}

2. Llamar a una herramienta con el ID de sesión:

POST /api/open/v1/streamable?sessionId=194830ab-eb0b-4d17-a574-af96705276c2
Content-Type: application/json
Authorization: Bearer YOUR_API_KEY

{
  "jsonrpc": "2.0",
  "method": "callTool",
  "params": {
    "name": "search_mcp_hub",
    "arguments": {
      "keywords": "example"
    }
  },
  "id": "call-1"
}

Desarrollo e implementación

Desarrollo

1. Instalar dependencias: pnpm install

2. Compilación: pnpm run build (compila TypeScript a JavaScript en build/ )

3. Modo de vigilancia: pnpm run watch (se recompila automáticamente al realizar cambios)

4. Pruebas con Inspector: pnpm run inspector (ejecuta el servidor con la herramienta MCP Inspector)

Creación de su propio servidor MCP basado en stdio

Si desea crear su propio servidor MCP basado en stdio, siga estos pasos:

1. Configura tu proyecto:

   mkdir my-mcp-server
   cd my-mcp-server
   npm init -y
   npm install @modelcontextprotocol/sdk

2. Crea la implementación de tu servidor:

// index.ts
import { Server } from '@modelcontextprotocol/sdk/server';
import { 
  CallToolRequestSchema, 
  ListToolsRequestSchema,
  McpError,
  ErrorCode
} from '@modelcontextprotocol/sdk/types';
import { StdioTransport } from '@modelcontextprotocol/sdk/transports/stdio';

// Create an MCP server instance
const server = new Server(
  {
    name: "my-mcp-server",
    version: "1.0.0"
  },
  {
    capabilities: {
      tools: {},
    }
  }
);

// Set up tool handlers
server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: 'my_tool',
      description: 'Description of my tool',
      inputSchema: {
        type: 'object',
        properties: {
          param1: {
            type: 'string',
            description: 'Description of param1',
          },
        },
        required: ['param1'],
      },
    },
  ],
}));

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  // Extract tool name and arguments
  const toolName = request.params.name;
  const args = request.params.arguments;
  
  if (toolName === 'my_tool') {
    // Validate arguments
    if (typeof args !== 'object' || args === null || typeof args.param1 !== 'string') {
      throw new McpError(
        ErrorCode.InvalidParams,
        'Invalid arguments. Requires "param1" (string).'
      );
    }
    
    try {
      // Implement your tool logic here
      const result = `Processed: ${args.param1}`;
      
      return {
        content: [
          {
            type: 'text',
            text: result,
          },
        ],
      };
    } catch (error) {
      return {
        content: [
          {
            type: 'text',
            text: `Error: ${error instanceof Error ? error.message : String(error)}`,
          },
        ],
        isError: true,
      };
    }
  } else {
    throw new McpError(
      ErrorCode.MethodNotFound,
      `Unknown tool: ${toolName}`
    );
  }
});

// Connect the server to stdin/stdout
const transport = new StdioTransport();
server.connect(transport).catch(console.error);

3. Compila y ejecuta tu servidor:

   npx tsc
   node dist/index.js

4. Pruebe su servidor con la herramienta MCP Inspector:

   npx @modelcontextprotocol/inspector

Despliegue

1. Asegúrese de que el servidor esté compilado ( pnpm run build ).

2. El directorio build contiene los archivos JavaScript necesarios.

3. El servidor se puede ejecutar utilizando node build/index.js o el comando mcphub_tools si el paquete está instalado adecuadamente (por ejemplo, globalmente o vinculado).

4. Configure su cliente/administrador MCP para que apunte al ejecutable del servidor y proporcione la variable de entorno MCP_HUB_API_KEY .

También puede publicar su servidor MCP en npm para que otros puedan instalarlo y usarlo.