de en es ja ko ru zh

Cursor MCP Installer

Name: Cursor MCP Installer
Author: matthewdcage

by matthewdcage

Overview Schema Related Servers Score Discussions

TypeScript

Hybrid

             _   _ _   _ _____     _______ ____  ____    _    _     
            | | | | \ | |_ _\ \   / / ____|  _ \/ ___|  / \  | |    
            | | | |  \| || | \ \ / /|  _| | |_) \___ \ / _ \ | |    
            | |_| | |\  || |  \ V / | |___|  _ < ___) / ___ \| |___ 
             \___/|_| \_|___|  \_/  |_____|_| \_\____/_/   \_\_____|
                                                          
      __  __  ____ ____    ___ _   _ ____ _____  _    _     _     _____ ____  
     |  \/  |/ ___|  _ \  |_ _| \ | / ___|_   _|/ \  | |   | |   | ____|  _ \ 
     | |\/| | |   | |_) |  | ||  \| \___ \ | | / _ \ | |   | |   |  _| | |_) |
     | |  | | |___|  __/   | || |\  |___) || |/ ___ \| |___| |___| |___|  _ < 
     |_|  |_|\____|_|     |___|_| \_|____/ |_/_/   \_\_____|_____|_____|_| \_\

License: MIT npm version MCP Compatible npm downloads

🚀 NEU: Universal MCP Installer v1.0.0 — Vollständige Neufassung von cursor-mcp-installer. Unterstützt jetzt 6 KI-Clients (Claude Desktop, Cursor, VS Code, OpenClaw, Claude Code, ChatGPT), ist plattformübergreifend (macOS, Windows, Linux), bietet echte MCP-Handshake-Validierung und ein gebrandetes Web-Dashboard. Aktualisiert auf MCP SDK 1.29.0.

🖥️ Web-Dashboard verfügbar! Starten Sie mit npx universal-mcp-installer --ui, um alles über eine visuelle Oberfläche zu verwalten. Siehe Verwendung des Dashboards unten.

Kurzanleitung

Schritt 1: Installieren Sie einen MCP-Server (Ein Befehl)

npx universal-mcp-installer install @modelcontextprotocol/server-memory

Das ist alles. Der Installer erkennt, welche KI-Clients Sie installiert haben, und schreibt die korrekte Konfiguration für jeden einzelnen.

Schritt 2: Oder als MCP-Tool hinzufügen (Lassen Sie Ihre KI andere MCP-Server installieren)

Fügen Sie dies zur MCP-Konfiguration Ihres KI-Clients hinzu:

Cursor (`~/.cursor/mcp.json`)

{
  "mcpServers": {
    "MCP Installer": {
      "command": "npx",
      "type": "stdio",
      "args": ["-y", "universal-mcp-installer"]
    }
  }
}

Claude Desktop (`claude_desktop_config.json`)

{
  "mcpServers": {
    "MCP Installer": {
      "command": "npx",
      "args": ["-y", "universal-mcp-installer"]
    }
  }
}

VS Code (`.vscode/mcp.json`)

{
  "servers": {
    "mcpInstaller": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "universal-mcp-installer"]
    }
  }
}

Schritt 3: Starten Sie Ihren KI-Client neu

Schließen Sie Ihren KI-Client und öffnen Sie ihn erneut, um die Konfigurationsänderungen anzuwenden.

Schritt 4: Bitten Sie Ihre KI, Server zu installieren

Install the filesystem MCP server

oder

Install the web search MCP server

Der Installer stellt drei Tools bereit, die Ihre KI aufrufen kann:

Tool	Beschreibung
`detect_system`	Gibt Betriebssystem, Architektur, verfügbare Runtimes und erkannte KI-Clients zurück
`install_mcp_server`	Installiert einen Server per Paketname, Git-URL oder lokalem Pfad für ausgewählte Clients
`validate_mcp_server`	Validiert einen Server per MCP-Handshake und gibt das Ergebnis zurück

Related MCP server: hyper-mcp

Verwendung des Dashboards

Starten Sie die visuelle Oberfläche:

npx universal-mcp-installer --ui

Dies öffnet die Weboberfläche in Ihrem Browser unter http://localhost:3939:

1. System-Panel — Der obere Bereich erkennt automatisch Ihr Betriebssystem und alle verfügbaren Runtimes (Node, npm, uvx, Python, git), sodass Sie auf einen Blick sehen können, was auf Ihrem Rechner verfügbar ist.

2. KI-Clients — Jeder erkannte Client erhält eine Karte, die seinen Namen, den Pfad zur Konfigurationsdatei und die Anzahl der bereits konfigurierten MCP-Server anzeigt. Verwenden Sie den Umschalter auf jeder Karte, um ihn für die nächste Installation einzubeziehen oder auszuschließen. Nicht installierte Clients erscheinen ausgegraut.

3. Installieren — Geben Sie einen Paketnamen ein (npm-Paket, Git-URL oder lokaler Pfad), wählen Sie eine Methode aus dem Dropdown-Menü (Auto / npm / uvx / git / local) und klicken Sie auf den grünen Installieren-Button. Der Installer löst das Paket auf, schreibt die Konfiguration in jeden aktivierten Client und validiert per MCP-Handshake.

4. Fortschritt & Ergebnisse — Eine Echtzeit-Timeline zeigt jeden Schritt (Auflösen, Konfiguration schreiben, Validieren) mit Live-Status-Updates via WebSocket. Nach Abschluss zeigt ein Gesundheitsbericht-Raster Erfolg/Fehlschlag pro Client mit Tool-Anzahl, Latenz und Hinweisen zur Fehlerbehebung bei Problemen.

Unterstützte Clients

Client	Konfigurationsschlüssel	Plattformen
Claude Desktop	`mcpServers`	macOS, Windows, Linux
Cursor	`mcpServers`	macOS, Windows, Linux
VS Code (Copilot)	`servers`	Alle (auf Workspace-Ebene)
OpenClaw / NemoClaw	`mcp.servers`	macOS, Linux
Claude Code	`mcpServers`	macOS, Windows, Linux
ChatGPT Desktop	HTTP Bridge	Alle (via lokalem HTTP-Proxy)

Wo befinden sich die Konfigurationsdateien?

Client	macOS	Windows	Linux
Claude Desktop	`~/Library/Application Support/Claude/claude_desktop_config.json`	`%APPDATA%\Claude\claude_desktop_config.json`	`~/.config/Claude/claude_desktop_config.json`
Cursor	`~/.cursor/mcp.json`	`%USERPROFILE%\.cursor\mcp.json`	`~/.cursor/mcp.json`
VS Code	`.vscode/mcp.json` (Workspace)	`.vscode/mcp.json` (Workspace)	`.vscode/mcp.json` (Workspace)
OpenClaw	`~/.openclaw/openclaw.json`	-	`~/.openclaw/openclaw.json`
Claude Code	`.mcp.json` (Projekt-Root)	`.mcp.json` (Projekt-Root)	`.mcp.json` (Projekt-Root)

Funktionen

Automatische Erkennung installierter KI-Clients und deren Konfigurationspfade
Runtime-Erkennung für Node.js, npm, npx, uvx, Python und git
Mehrere Installationsmethoden: npm, uvx, git clone, lokaler Pfad
Konfigurationssicherheit: erstellt Backups bestehender Konfigurationen, atomare Schreibvorgänge, überschreibt niemals unabhängige Schlüssel
Echte MCP-Handshake-Validierung: startet den Server, sendet initialize/initialized, ruft tools/list auf
Gesundheitsberichte: strukturierte Erfolg/Fehlschlag-Anzeige pro Client mit Tool-Anzahl, Latenz und Hinweisen zur Fehlerbehebung
Wiederherstellung bei bekannten Problemen: 13+ Fehlercodes mit umsetzbaren Lösungsvorschlägen
Plattformübergreifend: Windows cmd /c npx-Wrapping, Linux XDG-Pfade, macOS launchd-Unterstützung
Service-Templates: Generierung von Konfigurationen für launchd (macOS), systemd (Linux) oder Aufgabenplanung (Windows)
Web-Dashboard: gebrandete React-UI mit Echtzeit-WebSocket-Fortschritts-Updates

Voraussetzungen

Node.js v18 oder neuer
Mindestens ein unterstützter KI-Client installiert

Optional:

uv/uvx für Python MCP-Server
git für die Installation aus Repositories

CLI-Referenz

# Detect your system, runtimes, and installed AI clients
npx universal-mcp-installer detect

# Install an MCP server to all detected clients
npx universal-mcp-installer install @modelcontextprotocol/server-memory

# Install to specific clients only
npx universal-mcp-installer install my-server --clients cursor,claude-desktop

# Install with environment variables
npx universal-mcp-installer install my-server --env API_KEY=sk-123

# Install from a git repository
npx universal-mcp-installer install https://github.com/user/mcp-server.git

# Install from a local directory
npx universal-mcp-installer install ./my-local-server --method local

# Validate an MCP server by running the handshake
npx universal-mcp-installer validate npx -y @modelcontextprotocol/server-memory

# Launch the web dashboard
npx universal-mcp-installer --ui

CLI-Optionen

Option	Beschreibung
`--clients <ids>`	Kommagetrennte Client-IDs: `cursor`, `claude-desktop`, `vscode`, `openclaw`, `claude-code`, `chatgpt`
`--method <method>`	Installationsmethode: `auto`, `npm`, `uvx`, `git`, `local`
`--env KEY=value`	Umgebungsvariable (wiederholbar)
`--args <arg>`	Server-Argument (wiederholbar)
`--no-validate`	Überspringt die MCP-Handshake-Validierung nach der Installation
`--port <number>`	Dashboard-Port (Standard: 3939)

API-Endpunkte (Dashboard-Modus)

Beim Ausführen mit --ui ist eine lokale API verfügbar:

Endpunkt	Methode	Beschreibung
`/api/system`	GET	Systeminformationen, Runtimes, erkannte Clients
`/api/clients`	GET	Details zur Client-Erkennung
`/api/install`	POST	Installation auslösen
`/api/validate`	POST	MCP-Handshake-Validierung auslösen
`/ws`	WebSocket	Echtzeit-Fortschrittsereignisse

Entwicklung

# Clone and install
git clone https://github.com/matthewdcage/cursor-mcp-installer.git
cd cursor-mcp-installer
npm install

# Build the server
npm run build

# Build the dashboard
cd dashboard && npm install && npm run build && cd ..

# Run tests (real MCP handshake, no mocks)
npm test

# Watch mode
npm run dev

Projektstruktur

src/
  index.ts               MCP server entry (stdio)
  cli.ts                 CLI entry (npx)
  detect/                OS, runtime, client detection
  clients/               Config writers per AI client
  install/               Package resolution (npm, uvx, git, local)
  validate/              MCP handshake + health reports
  api/                   HTTP/WebSocket API for dashboard
  utils/                 Config I/O, logging, errors, platform utils
dashboard/               React + Vite + Tailwind web UI
tests/                   Unit, integration, E2E tests
docs/                    Localized official MCP docs

Changelog

v1.0.0 (Universelle Neufassung)

Vollständige Neufassung von cursor-mcp-installer (v0.1.3) zu universal-mcp-installer
Upgrade des MCP SDK von ^1.0.1 auf ^1.29.0 (28 Nebenversionen)
Unterstützung für 6 KI-Clients hinzugefügt (zuvor nur Cursor)
Echte MCP-Handshake-Validierung hinzugefügt (zuvor keine)
Plattformübergreifende Unterstützung mit plattformspezifischen Konfigurationspfaden hinzugefügt
CLI mit detect-, install-, validate-Befehlen hinzugefügt
Web-Dashboard mit React + Tailwind + WebSocket hinzugefügt
50+ echte Tests hinzugefügt (zuvor echo "No tests specified")
Datenbank zur Wiederherstellung bei bekannten Problemen hinzugefügt
Generierung von Service-Templates hinzugefügt (launchd, systemd, Aufgabenplanung)
rimraf/spawn-rx durch Node-eigene Funktionen ersetzt
Behoben: require.resolve im ESM-Kontext
Behoben: console.error/console.warn beschädigte den stdio JSON-RPC-Stream
Vollständige TypeScript-Quelle (zuvor nur kompiliertes JS-Artefakt)

Lizenz

MIT

Available Tools

3 tools

add_to_cursor_configC

Add any MCP server to Cursor's configuration

ParametersJSON Schema

Name	Required	Description
`args`	No	Arguments to pass to the command
`command`	No	Command to execute (e.g., node, npx, python)
`env`	No	Environment variables to set, delimited by =
`name`	Yes	Display name for the MCP server in Cursor
`path`	No	Path to the MCP server on disk (optional, used instead of command+args)

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden for behavioral disclosure. It states the action ('Add') but doesn't explain what this entails—whether it modifies configuration files, requires specific permissions, has side effects, or what happens on success/failure. For a configuration mutation tool, this is a significant gap in transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clear sentence that efficiently conveys the core purpose without unnecessary words. It's front-loaded and wastes no space, making it easy for an agent to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool that mutates configuration (implied by 'Add') with 5 parameters, no annotations, and no output schema, the description is insufficient. It doesn't address behavioral aspects like permissions, side effects, or error handling, nor does it help differentiate from sibling tools, leaving the agent with incomplete context for safe and effective use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all 5 parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema, such as explaining relationships between parameters (e.g., 'path' vs 'command+args') or usage examples. Baseline 3 is appropriate when schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Add') and resource ('any MCP server to Cursor's configuration'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'install_local_mcp_server' or 'install_repo_mcp_server', which likely handle more specific installation scenarios.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus its siblings ('install_local_mcp_server', 'install_repo_mcp_server'), nor does it mention any prerequisites, alternatives, or exclusion criteria. This leaves the agent without context for tool selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

install_local_mcp_serverC

Install an MCP server whose code is cloned locally on your computer

ParametersJSON Schema

Name	Required	Description
`args`	No	The arguments to pass along
`env`	No	The environment variables to set, delimited by =
`path`	Yes	The path to the MCP server code cloned on your computer

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action is 'Install', implying a write operation, but doesn't cover permissions needed, side effects (e.g., system changes), error handling, or output format. This leaves significant gaps for a tool that likely modifies the local environment.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and appropriately sized, making it easy to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of an installation tool with no annotations and no output schema, the description is insufficient. It lacks details on behavioral traits (e.g., what 'Install' entails operationally), prerequisites, or expected outcomes, leaving the agent with incomplete context for safe and effective use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all three parameters (path, args, env) with clear descriptions. The description adds no additional parameter semantics beyond what's in the schema, such as examples or constraints, resulting in the baseline score for high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Install') and the resource ('an MCP server whose code is cloned locally on your computer'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'install_repo_mcp_server' beyond the 'cloned locally' detail, which is implied but not contrasted.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'install_repo_mcp_server' or 'add_to_cursor_config'. It mentions the resource is 'cloned locally', which hints at a prerequisite, but lacks explicit when/when-not instructions or named alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

install_repo_mcp_serverC

Install an MCP server via npx or uvx

ParametersJSON Schema

Name	Required	Description
`args`	No	The arguments to pass along
`env`	No	The environment variables to set, delimited by =
`name`	Yes	The package name of the MCP server

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden but lacks behavioral details. It states the installation action but doesn't disclose critical traits like required permissions, side effects (e.g., system changes), error handling, or output format. This leaves significant gaps for an agent to understand the tool's behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with zero waste. It's front-loaded with the core action and methods, making it easy to parse quickly without unnecessary elaboration.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of installing software (a mutation operation with potential side effects), no annotations, and no output schema, the description is incomplete. It lacks details on prerequisites, success/failure outcomes, and behavioral context, making it insufficient for safe and effective tool invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all parameters (name, args, env). The description adds no additional meaning beyond what the schema provides, such as examples or usage context for parameters. Baseline 3 is appropriate as the schema handles parameter documentation adequately.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Install') and resource ('MCP server'), specifying the installation methods ('via npx or uvx'). However, it doesn't differentiate from sibling tools like 'install_local_mcp_server', which likely handles local installations versus this tool's package-based approach.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use this tool versus alternatives is provided. The description mentions installation methods but doesn't clarify scenarios where 'install_repo_mcp_server' is preferred over 'install_local_mcp_server' or other siblings, leaving usage context ambiguous.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.5/5.0

Disambiguation5/5

Each tool has a clearly distinct purpose: adding servers to config, installing from local code, and installing from remote repositories. There is no overlap or ambiguity between these three installation-related operations.

Naming Consistency4/5

The tools follow a consistent verb_object pattern (add_to..., install_..., install_...), though 'add_to_cursor_config' uses a prepositional phrase while the others use adjective-noun modifiers. This minor deviation doesn't significantly impact readability.

Tool Count5/5

Three tools is perfectly appropriate for an MCP installer server. Each tool covers a distinct installation scenario (config addition, local install, remote install), and there are no missing or redundant tools for this focused purpose.

Completeness5/5

The toolset provides complete coverage for MCP server installation workflows: adding to configuration, installing from local sources, and installing from remote repositories. There are no obvious gaps in the installation lifecycle for this domain.

Maintenance

ActivityInactive

ResponsivenessUnresponsive

Resources

Need Help?

Reddit Discussion

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

hithereiamaliff-mcp-nextcloudOAuth
ai.smithery
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Cloud Storage File Systems Workplace & Productivity
237
docs
dev.continue
An MCP server for docs.continue.dev
Documentation Access Developer Tools Search
2
Mercado Pago
com.mercadopago.mcp
The Mercado Pago MCP Server implements the Model Context Protocol to provide AI agents and LLMs with access to Mercado Pago's APIs and tools within compatible development environments. It acts as an intermediary that translates Mercado Pago resources into executable functions (tools) that AI applications can invoke to perform actions and automate flows. The server simplifies integration, enables using documentation to implement or improve code, and optimizes operations through natural language interactions without manual implementations.
Finance E-commerce & Retail App Automation
2
anotherai
dev.anotherai
MCP server for building and testing AI agents with multi-model experimentation and insights.
Agent Orchestration Autonomous Agents Testing & QA Tools
2

Related MCP Servers

DevEnvInfoServer
Developer Tools Databases
carterlasalle
A
license
Not graded
quality
D
maintenance
An MCP server that provides detailed information about your development environment to the Cursor code editor, enabling more context-aware assistance.
Updated 4 months ago (2026-05-04 06:24 UTC)
7
MIT
hyper-mcp
Agent Orchestration Developer Tools
kranners
A
license
Not graded
quality
F
maintenance
A configurable MCP server wrapper for Cursor that eliminates tool count limits when using the Model Context Protocol.
Updated 6 months ago (2026-02-27 04:56 UTC)
21
10
GPL 3.0
Awesome-MCP-Scaffold
Developer Tools Code Execution App Automation
WW-AI-Lab
A
license
Not graded
quality
C
maintenance
A production-ready development scaffold for MCP servers, optimized for Cursor IDE with built-in tools, resources, and prompts that enables quick development of Model Context Protocol servers with 5-minute startup and 10-minute development capabilities.
Updated a year ago (2025-07-11 07:34 UTC)
26
MIT
Shellagent MCP Server
Shell Access Command Line Code Execution
myshell-joe
F
license
B
quality
D
maintenance
A Model Context Protocol (MCP) server that can be deployed locally via stdio or remotely via SSE/HTTP endpoints, supporting multiple MCP clients including VS Code, Cursor, Windsurf, and Claude Desktop.
Updated a year ago (2025-06-19 16:14 UTC)
1

Appeared in Searches

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/matthewdcage/cursor-mcp-installer'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

Kurzanleitung

Schritt 1: Installieren Sie einen MCP-Server (Ein Befehl)

Schritt 2: Oder als MCP-Tool hinzufügen (Lassen Sie Ihre KI andere MCP-Server installieren)

Cursor (~/.cursor/mcp.json)

Claude Desktop (claude_desktop_config.json)

VS Code (.vscode/mcp.json)

Schritt 3: Starten Sie Ihren KI-Client neu

Schritt 4: Bitten Sie Ihre KI, Server zu installieren

Verwendung des Dashboards

Unterstützte Clients

Wo befinden sich die Konfigurationsdateien?

Funktionen

Voraussetzungen

CLI-Referenz

CLI-Optionen

API-Endpunkte (Dashboard-Modus)

Entwicklung

Projektstruktur

Changelog

v1.0.0 (Universelle Neufassung)

Lizenz

Available Tools

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Appeared in Searches

Latest Blog Posts

MCP directory API

Cursor (`~/.cursor/mcp.json`)

Claude Desktop (`claude_desktop_config.json`)

VS Code (`.vscode/mcp.json`)