mcphub_tools MCP-Server

Mit AIMCP-basierten MCP-Tools finden Sie alle gewünschten MCPs. Dieser Server ermöglicht die Suche im MCP-Hub nach verfügbaren MCPs.

Offenes Protokoll

Dieser Server implementiert das Model Context Protocol (MCP) . Er fungiert als MCP-Server, mit dem sich MCP-Clients (wie kompatible KI-Assistenten oder Entwicklungstools) verbinden können.

Related MCP server: Glama MCP Server Search

Einführung

mcphub_tools ist ein MCP-Server, der für die Interaktion mit dem MCP Hub entwickelt wurde. Seine Hauptfunktion besteht darin, ein Tool bereitzustellen, mit dem Benutzer anhand von Schlüsselwörtern nach im Hub registrierten MCPs (Model Context Protocols/Servers) suchen können.

Werkzeuge

Dieser Server stellt das folgende Tool bereit:

search_mcp_hub

• Beschreibung: Sucht nach MCPs auf dem MCP-Hub.

• Eingabeschema:

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

• Ausgabe: Gibt eine JSON-Zeichenfolge zurück, die die Suchergebnisse der MCP Hub-API enthält.

get_mcp_info

• Beschreibung: Ruft detaillierte Informationen zu einem bestimmten MCP ab.

• Eingabeschema:

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

• Ausgabe: Gibt eine JSON-Zeichenfolge zurück, die die detaillierten Informationen zum angegebenen MCP enthält.

Implementierungsoptionen

MCP Hub unterstützt zwei verschiedene Möglichkeiten zur Implementierung von MCP-Servern:

1. Standardmäßiger stdio-basierter MCP-Server

Dies ist die traditionelle Implementierung, bei der der MCP-Server über Standard-Ein-/Ausgabe (stdio) mit Clients kommuniziert. Dieser Ansatz eignet sich ideal für eigenständige Befehlszeilentools, die in MCP-Clients wie Claude Desktop integriert werden können.

Die einfachste Möglichkeit, die stdio-basierte Implementierung zu verwenden, ist über unser veröffentlichtes Paket:

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

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

2. HTTP-basierter MCP-Server

MCP Hub bietet außerdem eine HTTP-basierte Implementierung, die es KI-Assistenten und anderen Tools ermöglicht, sich über HTTP mit dem MCP-Server zu verbinden. Dies ist in der API des MCP Hubs unter /api/open/v1/streamable implementiert.

Der HTTP-Endpunkt ist verfügbar unter:

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

Verwendung

Voraussetzungen

• Node.js und npm (oder pnpm/yarn) für die stdio-basierte Implementierung installiert.

• Ein API-Schlüssel vom MCP Hub ( https://www.aimcp.info ).

So erhalten Sie einen API-Schlüssel

• Gehen Sie zu https://www.aimcp.info .

• Registrieren oder anmelden.

• Navigieren Sie zu Ihren Profil- oder Kontoeinstellungen.

• Suchen Sie nach einer Option zum Generieren oder Abrufen Ihres API-Schlüssels.

• Oder Sie können hier zugreifen, um einen API-Schlüssel zu generieren. HINWEIS: Der API-Schlüssel hat eine Ratenbegrenzung von 20 Anfragen pro Stunde.

Authentifizierung

Die MCP-API erfordert eine Authentifizierung mit einem gültigen API-Schlüssel. Dieser Schlüssel muss bereitgestellt werden über:

1. Für stdio-basierte Implementierung: Die Umgebungsvariable MCP_HUB_API_KEY .

2. Für die HTTP-basierte Implementierung: Der Authorization als Bearer-Token.

Authorization: Bearer YOUR_API_KEY

Integration mit KI-Assistenten und MCP-Clients

Claude Desktop-Konfiguration

So verwenden Sie MCP Hub mit Claude Desktop:

1. Suchen Sie Ihre Claude Desktop-Konfigurationsdatei:

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

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

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

2. Fügen Sie die folgende Konfiguration hinzu:

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

3. Starten Sie Claude Desktop neu, um die Änderungen zu übernehmen.

4. Sie können in Ihrer Konversation auf MCP Hub-Tools zugreifen, indem Sie „@mcp-hub“ eingeben.

Cline und andere CLI-Tools

Für befehlszeilenbasierte Tools wie Cline:

1. Erstellen Sie in Ihrem Projektverzeichnis eine Konfigurationsdatei mit dem Namen servers.json :

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

2. Starten Sie das Tool mit Bezug auf diese Konfiguration:

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

Für Tools, die Remote-MCP-Server unterstützen

Einige neuere MCP-Clients unterstützen direkte HTTP-Verbindungen. Konfigurieren Sie sie mit:

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

Für Tools mit dateibasierter Konfiguration (Cursor usw.)

1. Erstellen Sie eine Konfigurationsdatei:

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

2. Verweisen Sie in den Einstellungen Ihres Tools auf diese Datei oder starten Sie sie mit dem entsprechenden Konfigurationsparameter.

Manuelle Ausführung

Sie können den stdio-basierten Server auch manuell zum Testen ausführen (stellen Sie sicher, dass MCP_HUB_API_KEY in Ihrer Umgebung festgelegt ist):

export MCP_HUB_API_KEY="YOUR_API_KEY_HERE"
npx @aimcp/tools

API-Schnittstelle

Dieser Server interagiert mit dem folgenden MCP Hub-API-Endpunkt:

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

• Authentifizierung: Erfordert ein Bearer-Token im Authorization unter Verwendung des MCP_HUB_API_KEY .

• Abfrageparameter: keywords (Zeichenfolge)

Verwenden der HTTP-basierten MCP-API

MCP Hub bietet einen HTTP-basierten MCP-Server unter /api/open/v1/streamable der das Model Context Protocol implementiert. Dadurch können KI-Assistenten und -Tools nach MCPs suchen und MCP-Informationen direkt abrufen.

Verbindungsschritte

1. Stellen Sie zunächst eine Verbindung her, um eine Sitzungs-ID zu erhalten:

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

Antwort:

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

2. Rufen Sie ein Tool mit der Sitzungs-ID auf:

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"
}

Entwicklung und Bereitstellung

Entwicklung

1. Abhängigkeiten installieren: pnpm install

2. Build: pnpm run build (kompiliert TypeScript in JavaScript in build/ )

3. Überwachungsmodus: pnpm run watch (kompiliert bei Änderungen automatisch neu)

4. Testen mit Inspector: pnpm run inspector (führt den Server mit dem MCP Inspector-Tool aus)

Erstellen Sie Ihren eigenen stdio-basierten MCP-Server

Wenn Sie Ihren eigenen stdio-basierten MCP-Server erstellen möchten, führen Sie die folgenden Schritte aus:

1. Richten Sie Ihr Projekt ein:

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

2. Erstellen Sie Ihre Serverimplementierung:

// 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. Kompilieren und starten Sie Ihren Server:

   npx tsc
   node dist/index.js

4. Testen Sie Ihren Server mit dem MCP Inspector-Tool:

   npx @modelcontextprotocol/inspector

Einsatz

1. Stellen Sie sicher, dass der Server erstellt ist ( pnpm run build ).

2. Das build -Verzeichnis enthält die erforderlichen JavaScript-Dateien.

3. Der Server kann mit node build/index.js oder dem Befehl mcphub_tools ausgeführt werden, wenn das Paket entsprechend installiert ist (z. B. global oder verknüpft).

4. Konfigurieren Sie Ihren MCP-Client/Manager so, dass er auf die ausführbare Datei des Servers verweist, und geben Sie die Umgebungsvariable MCP_HUB_API_KEY an.

Sie können Ihren MCP-Server auch auf npm veröffentlichen, damit andere ihn installieren und verwenden können.