filesystem mcp server端部署

原创 于 2025-10-14 15:41:45 发布 · 492 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#node.js #AI编程

文章目录

filesystem mcp server端部署

服务器为rocky linux

安装nodejs

# 方法1：使用 NodeSource 仓库（推荐）
curl -fsSL https://rpm.nodesource.com/setup_18.x | bash -

# 安装 Node.js
dnf install -y nodejs

# 验证安装
node --version
npm --version
npx --version

# 方法2：如果上述方法失败，使用官方二进制包
# cd /opt
# wget https://nodejs.org/dist/v18.18.0/node-v18.18.0-linux-x64.tar.xz
# tar -xf node-v18.18.0-linux-x64.tar.xz
# ln -s /opt/node-v18.18.0-linux-x64/bin/node /usr/local/bin/node
# ln -s /opt/node-v18.18.0-linux-x64/bin/npm /usr/local/bin/npm
# ln -s /opt/node-v18.18.0-linux-x64/bin/npx /usr/local/bin/npx

创建项目目录：

mkdir -p /data/mcp/mcp-http-filesystem/{logs,data,shared}
cd /data/mcp/mcp-http-filesystem

# 初始化 Node.js 项目
npm init -y

# 安装生产依赖
npm install express

# 安装 MCP 文件系统服务器
npm install @modelcontextprotocol/server-filesystem

# 如果需要开发工具
npm install --save-dev nodemon

# 创建允许访问的目录
mkdir -p /data/mcp/mcp-http-filesystem/shared/documents
mkdir -p /data/mcp/mcp-http-filesystem/shared/projects
mkdir -p /data/mcp/mcp-http-filesystem/data

# 创建测试文件
echo "Hello from Rocky Linux MCP Server" > /data/mcp/mcp-http-filesystem/shared/welcome.txt
echo "Test document" > /data/mcp/mcp-http-filesystem/shared/documents/test.txt

创建 HTTP MCP 服务器主文件 http-mcp-server.js：

const express = require('express');
const { spawn } = require('child_process');
const fs = require('fs');
const path = require('path');

const app = express();

// 配置默认值
const config = {
    PORT: process.env.PORT || 8008,
    HOST: process.env.HOST || '0.0.0.0',
    NODE_ENV: process.env.NODE_ENV || 'production',
    LOG_LEVEL: process.env.LOG_LEVEL || 'info',
    SHARED_DIR: process.env.SHARED_DIR || '/data/mcp/mcp-http-filesystem/shared',
    DATA_DIR: process.env.DATA_DIR || '/data/mcp/mcp-http-filesystem/data',
    MAX_RESTARTS: parseInt(process.env.MAX_RESTARTS) || 5,
    REQUEST_TIMEOUT: parseInt(process.env.REQUEST_TIMEOUT) || 30000
};

// 尝试从 .env 文件加载配置
try {
    if (fs.existsSync('.env')) {
        const envContent = fs.readFileSync('.env', 'utf8');
        const envLines = envContent.split('\n').filter(line => line.trim() && !line.startsWith('#'));
        
        envLines.forEach(line => {
            const [key, value] = line.split('=').map(part => part.trim());
            if (key && value) {
                // 转换数字类型的配置
                if (['PORT', 'MAX_RESTARTS', 'REQUEST_TIMEOUT'].includes(key)) {
                    config[key] = parseInt(value);
                } else {
                    config[key] = value;
                }
            }
        });
    }
} catch (error) {
    console.warn('Warning: Could not load .env file, using defaults');
}

// 日志配置
const LOG_DIR = path.join(__dirname, 'logs');
const LOG_FILE = path.join(LOG_DIR, 'mcp-server.log');

// 确保日志目录存在
if (!fs.existsSync(LOG_DIR)) {
    fs.mkdirSync(LOG_DIR, { recursive: true });
}

// 日志函数
function log(level, message, data = null) {
    const timestamp = new Date().toISOString();
    const logMessage = `[${timestamp}] [${level}] ${message}` + (data ? ` ${JSON.stringify(data)}` : '');
    
    console.log(logMessage);
    fs.appendFileSync(LOG_FILE, logMessage + '\n');
}

// 根据配置的日志级别过滤日志
function shouldLog(level) {
    const levels = {
        error: 0,
        warn: 1,
        info: 2,
        debug: 3
    };
    return levels[level] <= levels[config.LOG_LEVEL];
}

app.use(express.json({ limit: '50mb' }));

log('INFO', `Starting MCP HTTP Server with configuration...`);
log('INFO', 'Configuration loaded', {
    port: config.PORT,
    host: config.HOST,
    environment: config.NODE_ENV,
    logLevel: config.LOG_LEVEL,
    sharedDir: config.SHARED_DIR,
    dataDir: config.DATA_DIR,
    maxRestarts: config.MAX_RESTARTS,
    requestTimeout: config.REQUEST_TIMEOUT
});

class HttpMcpServer {
    constructor() {
        this.mcpProcess = null;
        this.pendingRequests = new Map();
        this.requestId = 0;
        this.isInitialized = false;
        this.restartCount = 0;
        this.maxRestarts = config.MAX_RESTARTS;
        
        log('INFO', 'Initializing HTTP MCP Server');
        this.startMcpProcess();
    }

    startMcpProcess() {
        if (this.restartCount >= this.maxRestarts) {
            log('ERROR', 'Max restart attempts reached, stopping MCP process');
            return;
        }

        this.restartCount++;
        log('INFO', `Starting MCP filesystem process (attempt ${this.restartCount}/${this.maxRestarts})`);
        
        const sharedDir = config.SHARED_DIR;
        const dataDir = config.DATA_DIR;
        
        log('INFO', 'Allowed directories', { sharedDir, dataDir });
        
        // 确保目录存在
        [sharedDir, dataDir].forEach(dir => {
            if (!fs.existsSync(dir)) {
                fs.mkdirSync(dir, { recursive: true });
                log('INFO', 'Created directory', { directory: dir });
            }
        });
        
        try {
            // 使用正确的 MCP 服务器路径
            const mcpServerPath = path.join(__dirname, 'node_modules', '@modelcontextprotocol', 'server-filesystem', 'dist', 'index.js');
            
            log('INFO', 'Using MCP server path', { path: mcpServerPath });
            
            this.mcpProcess = spawn('node', [
                mcpServerPath,
                sharedDir,
                dataDir
            ], {
                stdio: ['pipe', 'pipe', 'pipe'],
                cwd: process.cwd(),
                env: { 
                    ...process.env, 
                    NODE_NO_WARNINGS: '1'
                }
            });

            log('INFO', 'MCP process spawned', { pid: this.mcpProcess.pid });

            // 处理 MCP 进程标准输出
            let buffer = '';
            this.mcpProcess.stdout.on('data', (data) => {
                const output = data.toString();
                buffer += output;
                
                if (shouldLog('debug')) {
                    log('DEBUG', 'MCP stdout', { output: output.trim() });
                }
                
                const lines = buffer.split('\n');
                for (let i = 0; i < lines.length - 1; i++) {
                    const line = lines[i].trim();
                    if (line) {
                        try {
                            const parsed = JSON.parse(line);
                            if (shouldLog('debug')) {
                                log('DEBUG', 'MCP JSON response', { 
                                    id: parsed.id, 
                                    method: parsed.method 
                                });
                            }
                            this.handleMcpResponse(parsed);
                        } catch (error) {
                            // 不是 JSON，可能是启动信息
                            if (line.includes('MCP') || line.includes('Server')) {
                                log('INFO', 'MCP startup message', { message: line });
                            }
                        }
                    }
                }
                buffer = lines[lines.length - 1];
            });

            // 处理错误输出
            this.mcpProcess.stderr.on('data', (data) => {
                const errorOutput = data.toString().trim();
                log('ERROR', 'MCP process stderr', { stderr: errorOutput });
            });

            // 处理进程退出
            this.mcpProcess.on('close', (code, signal) => {
                log('WARN', 'MCP process exited', { code, signal, restartCount: this.restartCount });
                
                this.pendingRequests.forEach((request, id) => {
                    request.reject(new Error(`MCP process terminated (code: ${code}, signal: ${signal})`));
                });
                this.pendingRequests.clear();
                
                this.isInitialized = false;
                this.mcpProcess = null;

                if (this.restartCount < this.maxRestarts) {
                    log('INFO', `Restarting MCP process in 10 seconds... (${this.restartCount}/${this.maxRestarts})`);
                    setTimeout(() => this.startMcpProcess(), 10000);
                } else {
                    log('ERROR', 'Max restart attempts reached, MCP process will not be restarted');
                }
            });

            this.mcpProcess.on('error', (error) => {
                log('ERROR', 'Failed to start MCP process', { error: error.message });
            });

            // 发送初始化请求
            setTimeout(() => {
                if (this.mcpProcess && !this.mcpProcess.killed) {
                    this.sendInitializeRequest();
                }
            }, 1000);

        } catch (error) {
            log('ERROR', 'Exception starting MCP process', { error: error.message });
        }
    }

    sendInitializeRequest() {
        const initRequest = {
            jsonrpc: "2.0",
            id: this.requestId++,
            method: "initialize",
            params: {
                protocolVersion: "2024-11-05",
                capabilities: {},
                clientInfo: {
                    name: "HTTP-MCP-Server",
                    version: "1.0.0"
                }
            }
        };

        log('INFO', 'Sending initialization request to MCP process');
        
        if (this.mcpProcess && !this.mcpProcess.killed) {
            this.mcpProcess.stdin.write(JSON.stringify(initRequest) + '\n');
        }
    }

    handleMcpResponse(response) {
        if (shouldLog('debug')) {
            log('DEBUG', 'Processing MCP response', { 
                id: response.id, 
                method: response.method,
                hasError: !!response.error
            });
        }

        if (response.jsonrpc === '2.0' && response.id !== undefined) {
            const pending = this.pendingRequests.get(response.id);
            if (pending) {
                const { resolve, reject, timeout } = pending;
                this.pendingRequests.delete(response.id);
                clearTimeout(timeout);
                
                if (response.error) {
                    log('ERROR', 'MCP request failed', { 
                        id: response.id, 
                        error: response.error 
                    });
                    reject(new Error(response.error.message || 'MCP error'));
                } else {
                    log('INFO', 'MCP request completed', { id: response.id });
                    resolve(response);
                }
            }
        }
        
        if (!this.isInitialized && response.result && response.result.protocolVersion) {
            this.isInitialized = true;
            this.restartCount = 0;
            log('INFO', 'MCP process initialized successfully');
        }
    }

    async sendRequest(request) {
        return new Promise((resolve, reject) => {
            if (!this.mcpProcess || this.mcpProcess.killed) {
                const error = 'MCP process not available';
                log('ERROR', error);
                reject(new Error(error));
                return;
            }

            const requestId = this.requestId++;
            const requestWithId = {
                ...request,
                jsonrpc: '2.0',
                id: requestId
            };

            log('INFO', 'Sending MCP request', { 
                id: requestId, 
                method: request.method 
            });

            const timeout = setTimeout(() => {
                if (this.pendingRequests.has(requestId)) {
                    this.pendingRequests.delete(requestId);
                    log('ERROR', 'Request timeout', { id: requestId });
                    reject(new Error(`Request ${requestId} timeout after ${config.REQUEST_TIMEOUT}ms`));
                }
            }, config.REQUEST_TIMEOUT);

            this.pendingRequests.set(requestId, { resolve, reject, timeout });

            try {
                this.mcpProcess.stdin.write(JSON.stringify(requestWithId) + '\n');
                if (shouldLog('debug')) {
                    log('DEBUG', 'Request sent to MCP process', { id: requestId });
                }
            } catch (error) {
                this.pendingRequests.delete(requestId);
                clearTimeout(timeout);
                log('ERROR', 'Failed to send request', { 
                    id: requestId, 
                    error: error.message 
                });
                reject(new Error(`Failed to send request: ${error.message}`));
            }
        });
    }
}

// 创建 HTTP MCP 服务器实例
const mcpServer = new HttpMcpServer();

// 配置查看端点
app.get('/config', (req, res) => {
    // 返回安全的配置信息（不包含敏感信息）
    const safeConfig = {
        port: config.PORT,
        host: config.HOST,
        environment: config.NODE_ENV,
        logLevel: config.LOG_LEVEL,
        sharedDir: config.SHARED_DIR,
        dataDir: config.DATA_DIR,
        maxRestarts: config.MAX_RESTARTS,
        requestTimeout: config.REQUEST_TIMEOUT
    };
    res.json(safeConfig);
});

// 健康检查端点
app.get('/health', (req, res) => {
    const status = {
        status: 'ok',
        timestamp: new Date().toISOString(),
        mcpProcess: mcpServer.mcpProcess && !mcpServer.mcpProcess.killed ? 'running' : 'stopped',
        mcpInitialized: mcpServer.isInitialized,
        pendingRequests: mcpServer.pendingRequests.size,
        restartCount: mcpServer.restartCount
    };
    if (shouldLog('debug')) {
        log('DEBUG', 'Health check requested', { client: req.ip });
    }
    res.json(status);
});

// MCP 请求端点
app.post('/mcp', async (req, res) => {
    try {
        log('INFO', 'MCP request received', { 
            method: req.body.method,
            client: req.ip
        });
        
        if (!req.body.jsonrpc || req.body.jsonrpc !== '2.0') {
            throw new Error('Invalid JSON-RPC 2.0 request');
        }
        
        const response = await mcpServer.sendRequest(req.body);
        log('INFO', 'MCP request completed successfully', { method: req.body.method });
        res.json(response);
        
    } catch (error) {
        log('ERROR', 'MCP request failed', { 
            method: req.body?.method, 
            error: error.message 
        });
        res.status(500).json({
            jsonrpc: '2.0',
            error: {
                code: -32000,
                message: error.message
            }
        });
    }
});

// 获取服务器信息
app.get('/info', (req, res) => {
    const info = {
        name: 'HTTP MCP Filesystem Server - Configurable Version',
        version: '1.0.0',
        platform: process.platform,
        nodeVersion: process.version,
        serverTime: new Date().toISOString(),
        logFile: LOG_FILE,
        endpoints: {
            config: '/config',
            health: '/health',
            mcp: '/mcp',
            info: '/info',
            logs: '/logs'
        },
        status: {
            mcpProcess: mcpServer.mcpProcess && !mcpServer.mcpProcess.killed ? 'running' : 'stopped',
            initialized: mcpServer.isInitialized,
            restartCount: mcpServer.restartCount
        }
    };
    
    if (shouldLog('debug')) {
        log('DEBUG', 'Info endpoint requested', { client: req.ip });
    }
    res.json(info);
});

// 日志查看端点
app.get('/logs', (req, res) => {
    const lines = parseInt(req.query.lines) || 50;
    
    try {
        if (!fs.existsSync(LOG_FILE)) {
            return res.status(404).json({ error: 'Log file not found' });
        }
        
        const logContent = fs.readFileSync(LOG_FILE, 'utf8');
        const logLines = logContent.split('\n').filter(line => line.trim());
        const lastLines = logLines.slice(-lines);
        
        res.json({
            file: LOG_FILE,
            lines: lastLines,
            totalLines: logLines.length
        });
    } catch (error) {
        log('ERROR', 'Failed to read log file', { error: error.message });
        res.status(500).json({ error: 'Failed to read logs' });
    }
});

// 根路径
app.get('/', (req, res) => {
    res.json({
        message: 'MCP HTTP Filesystem Server (Configurable Version)',
        endpoints: ['/', '/config', '/health', '/info', '/mcp', '/logs'],
        documentation: 'Use POST /mcp for MCP requests'
    });
});

// 启动服务器
app.listen(config.PORT, config.HOST, () => {
    log('INFO', 'Server started successfully', {
        host: config.HOST,
        port: config.PORT,
        nodeVersion: process.version,
        platform: process.platform,
        logFile: LOG_FILE
    });
    
    console.log(`HTTP MCP Filesystem Server running on http://${config.HOST}:${config.PORT}`);
    console.log(`Log file: ${LOG_FILE}`);
    console.log(`Health check: curl http://localhost:${config.PORT}/health`);
    console.log(`Config check: curl http://localhost:${config.PORT}/config`);
});

// 优雅关闭处理
function gracefulShutdown(signal) {
    log('INFO', 'Received signal, shutting down', { signal });
    
    if (mcpServer.mcpProcess) {
        log('INFO', 'Stopping MCP process');
        mcpServer.mcpProcess.kill();
    }
    
    setTimeout(() => {
        log('INFO', 'Server shutdown complete');
        process.exit(0);
    }, 1000);
}

process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
process.on('SIGINT', () => gracefulShutdown('SIGINT'));

process.on('uncaughtException', (error) => {
    log('ERROR', 'Uncaught Exception', {
        error: error.message,
        stack: error.stack
    });
    process.exit(1);
});

process.on('unhandledRejection', (reason, promise) => {
    log('ERROR', 'Unhandled Rejection', {
        reason: reason instanceof Error ? reason.message : reason
    });
});

创建启动脚本 start-server.sh：

#!/bin/bash

# MCP HTTP Server Startup Script for Rocky Linux

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
cd "$SCRIPT_DIR"

echo "=========================================="
echo "   MCP HTTP Filesystem Server Startup"
echo "=========================================="
echo "Time: $(date)"
echo "User: $(whoami)"
echo "Directory: $(pwd)"
echo "Node.js: $(node --version)"
echo "NPM: $(npm --version)"
echo "=========================================="

# 检查 Node.js 是否安装
if ! command -v node &> /dev/null; then
    echo "Error: Node.js is not installed"
    exit 1
fi

# 检查依赖是否安装
if [ ! -d "node_modules" ]; then
    echo "Installing dependencies..."
    npm install
fi

# 设置环境变量
export NODE_ENV=production
export PORT=3000
export HOST=0.0.0.0

echo "Starting server..."
echo "Server will be available at: http://$(hostname -I | awk '{print $1}'):8008"

# 启动服务器
exec node http-mcp-server.js

给脚本执行权限：

chmod +x start-server.sh

创建 systemd 服务:

sudo vi /etc/systemd/system/mcp-http.service

内容如下：

[Unit]
Description=HTTP MCP Filesystem Server
After=network.target
Wants=network.target

[Service]
Type=simple
User=houlj
Group=houlj
WorkingDirectory=/data/mcp/mcp-http-filesystem
Environment=NODE_ENV=production
Environment=PORT=8008
Environment=HOST=0.0.0.0
ExecStart=/usr/bin/node /data/mcp/mcp-http-filesystem/http-mcp-server.js
Restart=always
RestartSec=10
StandardOutput=journal
StandardError=journal

# 安全设置
NoNewPrivileges=yes
PrivateTmp=yes
ProtectSystem=strict
ProtectHome=yes
ReadWritePaths=/data/mcp/mcp-http-filesystem

[Install]
WantedBy=multi-user.target

启用并启动服务：

sudo systemctl daemon-reload
sudo systemctl enable mcp-http.service
sudo systemctl start mcp-http.service

检查服务状态：

sudo systemctl status mcp-http.service
journalctl -u mcp-http.service -f  # 查看实时日志
sudo journalctl -u mcp-http.service -n 100 --no-pager # 后100行

测试服务器运行

# 测试健康检查
curl http://localhost:8008/health

# 测试服务器信息
curl http://localhost:8008/info

# 测试 MCP 端点（列出可用工具）
curl -X POST http://localhost:8008/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list",
    "params": {}
  }'

测试文件系统操作

# 测试列出允许的目录
curl -X POST http://localhost:8008/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "callTool",
    "params": {
      "name": "list_allowed_directories",
      "arguments": {}
    }
  }'

# 测试列出共享目录内容
curl -X POST http://localhost:8008/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 3,
    "method": "callTool",
    "params": {
      "name": "list_directory",
      "arguments": {
        "path": "/home/mcpserver/mcp-http-filesystem/shared"
      }
    }
  }'
  1. 从其他机器测试
# 从局域网内的其他机器测试
curl http://your-server-ip:8008/health

mcp客户端配置

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-over-http-client@latest",
        "http://your-server-ip:8008/mcp"
      ]
    }
  }
}
LLM的MCP协议：初识MCP，搭建第一个MCP Server
Criss@陈磊
01-03 2万+
MCP（Model Context Protocol），是一个开发的协议，标准化了应用程序如何为大模型提供上下文。MCP提供了一个标准的为LLM提供数据、工具的方式，使用MCP会更容易的构建Agent或者是基于LLM的复杂工作流。
MCP Server全能工具箱
xiezhipu的博客
04-02 554
是 GitHub 上最热门的开源项目之一，专注于协议的服务器实现，为开发者提供了超过 100 种开箱即用的工具模块，覆盖浏览器自动化、金融分析、数据库交互、知识管理、云服务等数十个领域。自 OpenAI 宣布其 Agent SDK 支持 MCP 后，该项目迅速成为智能体开发领域的标杆工具库，目前星标数已突破 20,000，并持续高频迭代。通过模块化设计和高扩展性，成为连接 AI 能力与实际业务场景的桥梁。无论是快速验证原型还是构建生产级应用，开发者均可通过其丰富的工具库显著提升效率。
必装的4个MCP Server介绍（程序员篇）
分享平时的学习心得和笔记
05-16 618
在编程领域，MCP Server 是提升开发效率的重要工具。本文推荐了四款必装的MCP Server：GitHub MCP Server（支持CI/CD集成）、mcp-server-git（专注于版本控制）、Filesystem MCP Server（轻量级文件管理）和BrowserTools MCP（浏览器自动化测试）。选择时需根据个人或团队需求，如个人开发者适合Filesystem MCP Server，团队开发推荐GitHub MCP Server和mcp-server-git，而BrowserToo
Filesystem MCP Server：安全文件系统操作的艺术
最新发布
gitblog_00826的博客
10-01 474
你是否还在为应用程序的文件系统访问安全而担忧？是否遇到过权限管理复杂、操作繁琐的问题？Filesystem MCP Server 为你提供了一站式解决方案，让文件系统操作既安全又高效。读完本文，你将了解如何轻松配置和使用 Filesystem MCP Server，掌握动态目录访问控制的技巧，并学会在不同环境中部署和应用这一强大工具。 ## 项目概述 Filesystem MCP Server...
Filesystem MCP服务器：安全文件系统操作的标准化接口
gitblog_00489的博客
08-22 733
Filesystem MCP服务器：安全文件系统操作的标准化接口 【免费下载链接】servers Model Context Protocol Servers 项目地址: https://gitcode.com/GitHub_Tr...
CherryStudio配置本地MCP服务器实现FileSystem本地文件系统读写操作
2401_84495872的博客
04-21 9840
以下是为Cherry Studio内置的MCP服务器添加FileSystem文件系统MCP组件的详细步骤：步骤1：安装UV和Bun工具FileSystem文件系统操作MCP组件的运行依赖UV和Bun工具，需先确保它们已正确安装：1. 自动安装（推荐）：打开Cherry Studio，进入【设置】 → 【MCP服务器】。
Cherry Studio + Filesystem MCP Server教程（保姆级手把手）：从零搭建你的专属AI文件管家，看这一篇就够了！
xiaoganbuaiuk的博客
08-18 1555
然而，由于科学上网的原因，国内用户不方便使用 Claude Desktop。本文介绍一款桌面 AI 客户端 Cherry Studio。Cherry Studio 是面向国内用户的 AI 桌面客户端，不仅具有 Claude Desktop 的文件交互能力，还提供多模型调度、编程助手与知识管理等进阶功能。本文主要内容：Cherry Studio 的功能特性与安装使用Filesystem MCP Server 介绍。
Cherry Studio+Filesystem MCP Server：搭建个人智能文件助手
2301_81888214的博客
07-07 1380
然而，由于科学上网的原因，国内用户不方便使用 Claude Desktop。本文介绍一款桌面 AI 客户端 Cherry Studio。Cherry Studio 是面向国内用户的 AI 桌面客户端，不仅具有 Claude Desktop 的文件交互能力，还提供多模型调度、编程助手与知识管理等进阶功能。本文主要内容：Cherry Studio 的功能特性与安装使用Filesystem MCP Server 介绍。
【笔记】MCP-Servers FileSystem 启动命令
Java程序员的知识博客
08-13 607
运行mcp server，模式stdio，允许访问目录：C:/Users/zhang。部署mcp代理，将stdio转换为sse，适配Agent。
在 Windows 系统里零代码搭建 MCP Server 详细教程
分享平时的学习心得和笔记
05-22 1175
在 Windows 系统下，零代码搭建 MCP（模型上下文协议）Server 是一个简化服务器架构搭建的过程，尤其适合没有深厚编程基础的用户。首先，了解 MCP Server 的基本概念和准备合适的硬件环境是关键。接着，选择一个合适的零代码开发平台，如“某易搭零代码平台”或“某数智零代码开发工具”，这些平台提供了直观的可视化界面和丰富的模板支持。搭建步骤包括注册登录平台、创建新项目、配置 MCP 协议相关基础信息、添加模型及上下文管理组件、设置数据交互流程以及进行测试与优化。此外，随着业务的发展，还可以对
Manus平替方案：用DeepSeek+MCP Server构建AI自主工作流
weixin_51702416的博客
05-16 907
在AI技术日新月异的今天，我们正见证着LLM（大语言模型）从"能说会道"向"能工巧匠"的进化。当Anthropic推出（MCP）时，它像一道闪电划破夜空——这个被称作"AI界的USB-C"的协议，正在重新定义人机协作的边界。作为一个沉迷于技术探索的开发者，我始终在寻找让AI真正"落地"的方法。当看到MCP协议支持本地文件操作、数据库访问甚至浏览器自动化时，一个大胆的想法在我脑中成型：能否在VS Code这个开发者主战场上，用零代码方案复刻类Manus的智能体能力。本文通过两个开源MCP Server。
MCP服务器本地化部署
ly_cyz的专栏
06-17 2200
MCP 服务器私有化部署
＜工具 Claude Desktop＞ 配置 MCP server 连接本地 SQLite， 本机文件夹(目录) 网络驱动器 Windows 11 系统
davenian的博客
12-03 9135
MCP：Claude Model Context Protocol 暂定义为 模型几段翻译：“今天，我们开源了 Model Context Protocol（MCP），这是一个将人工智能助手与数据存储系统（包括内容库、业务工具和开发环境）连接的新标准。其目的是帮助前沿模型生成更好、更相关的响应。“MCP 解决了这个挑战(模型与数据隔离)。它提供了一种通用的开放标准，用于将 AI 系统与数据源连接，取代了分散的集成，使用单一协议。结果是为 AI 系统提供所需数据的方式更简单、更可靠。
远程配置Vscode+Cline+McpServer（filesystem）踩坑记录
qq_57284773的博客
04-07 1000
我是普通用户，需要在实验室的远程服务器上用vscode+Mcpserverde filesystem，试了半天就是配不上这个filesystem。解决办法：commond路径写成自己安装的node的完整路径。参数filesystem也写成完整路径。原因是 普通用户没有权限，/usr/bin ，没办法识别自己安装的node。
【MCP基本介绍与使用】
qq_42277477的博客
05-09 955
sse 官方推荐使用uv包管理创建项目。mcp_client配置。
告别文件混乱：用Filesystem MCP实现AI自动整理文件夹
LCG元的博客
07-24 1864
Filesystem MCP（文件系统智能管理平台）是一个基于人工智能的自动化文件管理解决方案。它通过深度学习和自然语言处理技术，理解文件内容和用户习惯，自动实现文件分类、整理和标签化操作，彻底解决文件混乱问题。# 提供示例文件训练AI{"path": "/docs/ProjectPhoenix.pdf", "category": "项目提案"},{"path": "/docs/Q3_Expenses.xlsx", "category": "财务报告"},
MCP教程进阶篇，没学到最后你就放弃了！
2401_84204413的博客
03-21 1867
MCP（Model Control Protocol）是一个开放标准协议，专为控制和交互大型语言模型（LLMs）而设计。这个协议由Anthropic公司提出并开源，旨在提供一种标准化的方式来与AI模型进行通信。Cursor作为一款面向开发者的AI编辑器，原生集成了MCP协议，使开发者能够连接到任何兼容MCP的模型服务。这为开发团队提供了极大的灵活性，既可以使用公共AI服务，也可以连接到企业内部部署的AI模型。
盘点这8个MCP Server工具神器，拯救996职场打工人
hewenhu_21的博客
03-25 6551
8 个MCP server覆盖了代码管理、运维管理、文件处理管理、实时通信、网页抓取、项目协作管理等多个领域。如果你正寻找一种简洁高效的方法来增强应用功能，这些 MCP server无疑能够满足你的要求。你可以从中选择最符合自身需求的server，也可以多个工具进行组合使用。通过上述地址进一步了解或直接获取相应代码，体验这些强大工具，让你在工作中效率翻倍，从此告别无效加班！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值