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).
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:
- Para la implementación basada en stdio: la variable de entorno
MCP_HUB_API_KEY . - 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:
- 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
- Agregue la siguiente configuración:
{
"mcpServers": {
"mcp-hub": {
"command": "npx",
"args": ["@aimcp/tools"],
"environment": {
"MCP_HUB_API_KEY": "YOUR_API_KEY"
}
}
}
}
- Reinicie Claude Desktop para aplicar los cambios.
- 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:
- 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"
}
}
]
}
- 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.)
- Crear un archivo de configuración:
{
"mcpServers": {
"mcp-hub": {
"command": "npx",
"args": ["@aimcp/tools"],
"environment": {
"MCP_HUB_API_KEY": "YOUR_API_KEY"
}
}
}
}
- 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
- 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."
}
- 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
- Instalar dependencias:
pnpm install - Compilación:
pnpm run build (compila TypeScript a JavaScript en build/ ) - Modo de vigilancia:
pnpm run watch (se recompila automáticamente al realizar cambios) - 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:
- Configura tu proyecto:
mkdir my-mcp-server
cd my-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk
- 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);
- Compila y ejecuta tu servidor:
npx tsc
node dist/index.js
- Pruebe su servidor con la herramienta MCP Inspector:
npx @modelcontextprotocol/inspector
Despliegue
- Asegúrese de que el servidor esté compilado (
pnpm run build ). - El directorio
build contiene los archivos JavaScript necesarios. - 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). - 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.