{
  "mcpServers": {
    "storm": {
      "command": "sh",
      "args": [
        "/Users/sigridjineth/Desktop/work/storm-mcp-server/scripts/run.sh"
      ]
    }
  }
}

风暴模型上下文协议（Storm MCP）服务器与Sionic AI无服务器RAG

韩语 (한국어)

Storm MCP(모델 컨텍스트 프로토콜) 서버

Storm MCP(모델 컨텍스트 프로토콜) 서버는 대형 language model(LLM) 애플리케이션과 RAG 데이터 소스 및 도구 간의 원활한 통합을 가능하게 하는 개방형 프로토콜입니다. Anthropic의 Model Context Protocol을 구현하여 Claude Desktop에서 Storm Platform을 바로 이용할 수 있습니다.

Sionic AI 의 Storm Platform은 RAG 기술을 기반으로 한 제품이며, 이 서버는 Sionic AI의 서비스와 연계하여 사용자에게 더 많은 기능을 제공합니다. 이 서버를 통해 LLM과 RAG 데이터 간의 상호작용을 원활하게 관리하고, 다양한 도구 및 파일 관리를 가능케 합니다.

主要功能

1. 모델 컨텍스트 프로토콜 지원: Anthropic의 Model Context Protocol을 구현하여 Claude Desktop과 같은 LLM 플랫폼과 통합됩니다.
2. RAG 데이터 처리: 문서 업로딩, 분류, 검색 기능을 제공하여 RAG 작업을 수행할 수 있습니다.
3. 도구 시스템: send_nonstream_chat, list_agents, list_buckets, upload_document_by_file와 같은 도구를 정의하고 호출할 수 있습니다.
4. 파일 관리: 파일의 업로드, 다운로드, 삭제 등의 파일 시스템 작업을 지원합니다.
5. API 통합: Storm Platform의 REST API와 연결하여 다양한 기능을 제공합니다.

프로젝트 구조

• main.py: MCP 서버를 초기화하고 이벤트 핸들러를 설정합니다.
• core/file_manager.py: 파일 작업을 위한 FileSystemManager 클래스를 정의합니다.
• core/internal_api.py: Storm Platform의 REST API와 통신하기 위한 API 클라이언트 함수를 포함합니다.
• tools/tool_definitions.py: MCP 서버에서 사용할 도구들을 정의합니다.
• tools/tool_handlers.py: 도구 작업을 수행하기 위한 핸들러를 구현합니다.
• tools/tool_upload_file.py: 파일 업로드를 위한 전용 핸들러와 파일 서버를 구현합니다.

아키텍처

MCP는 다음과 같이 3개의 층으로 구성됩니다:

1. 호스트 (LLM 애플리케이션): 사용자가 요청을 보내고 응답을 받는 대화형 AI 플랫폼입니다.
2. 클라이언트 (프로토콜 구현): MCP 프로토콜을 구현하여 호스트와 통신합니다.
3. 서버 (기능 제공자): 리소스 및 도구를 제공하고 작업을 수행합니다.

시작 방법

Claude Desktop 환경에서 MCP 서버를 연결하려면 다음 설정을 적용해야 합니다.

1. 설정 파일 열기:

   code ~/Library/Application\ Support/Claude/claude_desktop_config.json
   

2. MCP 서버 설정 추가:

   {
     "mcpServers": {
       "storm": {
         "command": "sh",
         "args": [
           "/Users/sigridjineth/Desktop/work/storm-mcp-server/scripts/run.sh"
         ]
       }
     }
   }
   

---

日语 (日本語)

Storm MCP(モデル コンテキスト プロトコル) サーバー

Storm MCP(モデル コンテキスト プロトコル) サーバーは、大規模言語モデル(LLM) アプリケーションとRAGデータソースおよびツール間のスムoothな統合を可能にするオープンプロトコルです。Anthropicの Model Context Protocol を実装し、Claude DesktopでStormプラットフォームを利用できます。

Sionic AIのStormプラットフォームはRAG技術を基盤とした製品であり、このサーバーはSionic AIのサービスと連携してユーザーに更多的な機能を提供します。このサーバーを通じてLLMとRAGデータ間の相互作用をスムooth하게管理し、さまざまなツールやファイル管理を行うことが可能です。

主要功能

1. モデル コンテキ스트 プロトコル サポート: AnthropicのModel Context Protocolを実装し、Claude DesktopなどのLLMプラットフォームと統合します。
2. RAGデータ処理: 文書のアップロード、分類、検索機能を提供してRAG作業を行えます。
3. ツール システム: send_nonstream_chat, list_agents, list_buckets, upload_document_by_fileなどのツールを定義し呼び出すことができます。
4. ファイル管理: ファイルのアップロード、ダウンロード、削除などのファイルシステム作業を支援します。
5. API 統合: StormプラットフォームのREST APIと接続してさまざまな機能を提供します。

プロジェクト構成

• main.py: MCPサーバーを初期化し、イベントハンドラーを設定します。
• core/file_manager.py: ファイル作業を 위한 FileSystemManagerクラスを定義します。
• core/internal_api.py: StormプラットフォームのREST APIと通信するためのAPIクライアント関数を含みます。
• tools/tool_definitions.py: MCPサーバーで使用するツール들을定義します。
• tools/tool_handlers.py: ツール作業を行うためのハンドラーを実装します。
• tools/tool_upload_file.py: ファイル アップロード専用のハンドラーとファイル サーバーを実装します。

アーキテクチャ

MCPは以下のように3つのレイヤで構成されます:

1. ホスト (LLMアプリケーション): ユーザがリクエストを送信し、レスポンスを受け取るインタラクティブAIプラットフォームです。
2. クリアント (プロトコル実装): MCPプロトコルを実装してホストと通信します。
3. サーバー (機能提供者): リソースおよびツールを提供し、作業を行います。

開始方法

Claude Desktop 環境에서 MCPサーバーを接続するには次の設定を適用します。

1. 設定ファイルを開く:

   code ~/Library/Application\ Support/Claude/claude_desktop_config.json
   

2. MCPサーバー設定を追加:

   {
     "mcpServers": {
       "storm": {
         "command": "sh",
         "args": [
           "/Users/sigridjineth/Desktop/work/storm-mcp-server/scripts/run.sh"
         ]
       }
     }
   }
   

---

中文 (中文)

暴风 MCP（模型上下文协议）服务器

暴雪 MCP（模型上下文协议）服务器是一个支持大语言模型（LLM）应用程序与 RAG 数据源及工具之间平滑交互的开源协议。通过实现 Anthropic 的 Model Context Protocol，可以在 Claude Desktop 等平台上使用。

Sionic AI 的 暴雪平台 基于 RAG 技术构建，该服务器可与 Sionic AI 的服务结合，为用户提供更多功能。通过此服务器，可以实现 LLM 与 RAG 数据之间的平滑交互，并支持多种工具和文件管理操作。

主要功能

1. 模型上下文协议支持: 实现 Anthropic 的 Model Context Protocol，与 Claude Desktop 等 LLM 平台集成。
2. RAG数据处理: 提供文档上传、分类、检索等功能，支持 RAG 任务的执行。
3. 工具系统: 支持 send_nonstream_chat、list_agents、list_buckets、upload_document_by_file 等多种工具的定义与调用。
4. 文件管理: 提供文件的上传、下载、删除等文件系统操作功能。
5. API 集成: 与暴雪平台的 REST API 对接，提供多样化服务。

项目结构

• main.py: 初始化 MCP 服务器并配置事件处理器。
• core/file_manager.py: 定义用于文件操作的 FileSystemManager 类。
• core/internal_api.py: 包含与暴雪平台 REST API 通信的 API 客户端函数。
• tools/tool_definitions.py: 定义 MCP 服务器中使用的工具集。
• tools/tool_handlers.py: 实现处理各种工具操作的处理器。
• tools/tool_upload_file.py: 提供文件上传专用处理器和文件服务器实现。

架构

MCP 的架构分为以下三层：

1. 宿主（LLM 应用程序）: 用户发送请求并接收响应的交互式 AI 平台。
2. 客户端（协议实现）: 实现 MCP 协议并与宿主通信。
3. 服务器（功能提供者）: 提供资源和工具，处理各项任务。

启动方法

在 Claude Desktop 环境中启动 MCP 服务器，请按照以下步骤配置：

1. 打开设置文件:

   code ~/Library/Application\ Support/Claude/claude_desktop_config.json
   

2. 添加 MCP 服务器配置:

   {
     "mcpServers": {
       "storm": {
         "command": "sh",
         "args": [
           "/Users/sigridjineth/Desktop/work/storm-mcp-server/scripts/run.sh"
         ]
       }
     }
   }
   

---

English

Storm MCP (Model Context Protocol) Server

The Storm MCP server is an open-source protocol that enables seamless interaction between large language model (LLM) applications and RAG data sources and tools. By implementing the Anthropic Model Context Protocol, it can be used on platforms like Claude Desktop.

Sionic AI's Storm Platform is built upon RAG technology, and this server can integrate with Sionic AI services to provide additional functionalities for users. With this server, you can achieve smooth interaction between LLMs and RAG data, as well as support multiple tools and file management operations.

Key Features

1. Model Context Protocol Support: Implement the Anthropic Model Context Protocol for integration with LLM platforms like Claude Desktop.
2. RAG Data Processing: Offers functionalities such as document upload, classification, and retrieval to support RAG tasks.
3. Tool System: Supports various tools including send_nonstream_chat, list_agents, list_buckets, and upload_document_by_file.
4. File Management: Enables operations like file upload, download, and deletion for file system management.
5. API Integration: Connects with the Storm Platform's REST API to provide diverse services.

Project Structure

• main.py: Initializes the MCP server and configures event handlers.
• core/file_manager.py: Defines the FileSystemManager class for file operations.
• core/internal_api.py: Contains API client functions for communication with the Storm platform's REST API.
• tools/tool_definitions.py: Specifies tools used by the MCP server.
• tools/tool_handlers.py: Implements handlers for various tool operations.
• tools/tool_upload_file.py: Provides a handler and file server for document uploads.

Architecture

The MCP architecture is structured in three layers:

1. Host (LLM Application): An interactive AI platform where users send requests and receive responses.
2. Client (Protocol Implementation): Implements the MCP protocol and communicates with the host.
3. Server (Function Provider): Offers resources and tools, handling various tasks.

Getting Started

To start the MCP server on a Claude Desktop environment, follow these steps:

1. Open the Settings File:

   code ~/Library/Application\ Support/Claude/claude_desktop_config.json
   

2. Add MCP Server Configuration:

   {
     "mcpServers": {
       "storm": {
         "command": "sh",
         "args": [
           "/Users/sigridjineth/Desktop/work/storm-mcp-server/scripts/run.sh"
         ]
       }
     }
   }
   

---

Français

Serveur Storm MCP (Modèle Contexte Protocole)

Le serveur Storm MCP est un protocole open-source qui permet une interaction fluide entre les applications de grands modèles langagiers (LLM) et les sources de données RAG ainsi que les outils. En implémentant le Modèle Contexte Protocole d'Anthropic, il peut être utilisé sur des plateformes comme Claude Desktop.

La plateforme Storm Platform de Sionic AI est construite sur la technologie RAG, et ce serveur peut s'intégrer avec les services Sionic AI pour offrir plus de fonctionnalités utilisateur. Avec ce serveur, vous pouvez atteindre une interaction fluide entre les LLMs et les données RAG, ainsi que prendre en charge plusieurs outils et opérations de gestion de fichiers.

Principales Caractéristiques

1. Support du Protocole Modèle Contexte: Implémentation du protocole Modèle Contexte d'Anthropic pour l'intégration avec des plateformes LLM comme Claude Desktop.
2. Traitement des Données RAG: Fournit des fonctionnalités telles que le téléchargement de documents, la classification et la récupération pour supporter les tâches RAG.
3. Système d'Outils: Prend en charge divers outils incluant send_nonstream_chat, list_agents, list_buckets, et upload_document_by_file.
4. Gestion de Fichiers: Permet des opérations comme le téléchargement, le téléchargement et la suppression de fichiers pour la gestion du système de fichiers.
5. Intégration API: Se connecte avec l'API REST de la plateforme Storm pour fournir divers services.

Structure du Projet

• main.py: Initialise le serveur MCP et configure les handlers d'événements.
• core/file_manager.py: Définit la classe FileSystemManager pour les opérations de fichiers.
• core/internal_api.py: Contient des fonctions client API pour la communication avec l'API REST de la plateforme Storm.
• tools/tool_definitions.py: Spécifie les outils utilisés par le serveur MCP.
• tools/tool_handlers.py: Implémente des handlers pour diverses opérations d'outils.
• tools/tool_upload_file.py: Fournit un handler et un serveur de fichiers pour les téléchargements de documents.

Architecture

L'architecture du MCP est structurée en trois couches :

1. Hôte (Application LLM): Une plateforme interactive d'IA où les utilisateurs envoient des requêtes et reçoivent des réponses.
2. Client (Implémentation du Protocole): Implémente le protocole MCP et communique avec l'hôte.
3. Serveur (Fournisseur de Fonctionnalités): Fournit des ressources et outils, gérant diverses tâches.

Démarrage

Pour lancer le serveur MCP sur une plateforme Claude Desktop, suivez ces étapes :

1. Ouvrez le Fichier de Configuration:

   code ~/Library/Application\ Support/Claude/claude_desktop_config.json
   

2. Ajoutez la Configuration du Serveur MCP:

   {
     "mcpServers": {
       "storm": {
         "command": "sh",
         "args": [
           "/Users/sigridjineth/Desktop/work/storm-mcp-server/scripts/run.sh"
         ]
       }
     }
   }
   

---

Italiano

Server Storm MCP (Modello Contexto Protocollo)

Il server Storm MCP è un protoccolo open-source che consente un'interazione fluida tra le applicazioni di grandi modelli linguistici (LLM) e le fonti di dati RAG, nonché gli strumenti. Implementando il Modello Contexto Protocollo di Anthropic, può essere utilizzato su piattaforme come Claude Desktop.

La piattaforma Storm Platform di Sionic AI è costruita sulla tecnologia RAG, e questo server può integrarsi con i servizi Sionic AI per offrire ulteriori funzionalità agli utenti. Con questo server, è possibile ottenere un'interazione fluida tra i LLMs e i dati RAG, nonché supportare vari strumenti e operazioni di gestione dei file.

Principali Caratteristiche

1. Supporto al Protocollo Modello Contexto: Implementazione del protocollo Modello Contexto di Anthropic per l'integrazione con piattaforme LLM come Claude Desktop.
2. Elaborazione Dati RAG: Fornisce funzionalità quali il download di documenti, la classificazione e la recupero per supportare le task RAG.
3. Sistema degli Strumenti: Supporta vari strumenti tra cui send_nonstream_chat, list_agents, list_buckets, e upload_document_by_file.
4. Gestione dei File: Consente operazioni come il download, il download e l'eliminazione di file per la gestione del sistema di file.
5. Integrazione API: Si connette con l'API REST della piattaforma Storm per fornire vari servizi.

Struttura del Progetto

• main.py: Inizializza il server MCP e configura i handler degli eventi.
• core/file_manager.py: Definisce la classe FileSystemManager per le operazioni di file.
• core/internal_api.py: Contiene funzioni client API per la comunicazione con l'API REST della piattaforma Storm.
• tools/tool_definitions.py: Specifica gli strumenti utilizzati dal server MCP.
• tools/tool_handlers.py: Implementa handler per varie operazioni di strumenti.
• tools/tool_upload_file.py: Fornisce un handler e un server di file per i download di documenti.

Architettura

L'architettura del MCP è strutturata in tre livelli :

1. Host (Applicazione LLM): Una piattaforma interattiva di IA dove gli utenti inviano richieste e ricevono risposte.
2. Client (Implementazione del Protoccolo): Implementa il protoccolo MCP e comunica con l'host.
3. Server (Fornitore di Funzionalità): Fornisce risorse e strumenti, gestendo diverse task.

Avvio

Per avviare il server MCP su una piattaforma Claude Desktop, segui questi passaggi :

1. Apri il File di Configurazione:

   code ~/Library/Application\ Support/Claude/claude_desktop_config.json
   

2. Aggiungi la Configurazione del Server MCP:

   {
     "mcpServers": {
       "storm": {
         "command": "sh",
         "args": [
           "/Users/sigridjineth/Desktop/work/storm-mcp-server/scripts/run.sh"
         ]
       }
     }
   }
   

---

Español

Servidor Storm MCP (Modelo Contexto Protocollo)

El servidor Storm MCP es un protocolo open-source que permite una interacción fluida entre las aplicaciones de grandes modelos lingüísticos (LLM) y las fuentes de datos RAG, así como las herramientas. Implementando el Modelo Contexto Protocollo de Anthropic, puede utilizarse en plataformas como Claude Desktop.

La plataforma Storm Platform de Sionic AI está construida sobre la tecnología RAG, y este servidor puede integrarse con los servicios de Sionic AI para ofrecer funciones adicionales a los usuarios. Con este servidor, es posible obtener una interacción fluida entre los LLMs y los datos RAG, así como apoyar vari herramientas y operaciones de gestión de archivos.

Principales Características

1. Soporte al Protocollo Modelo Contexto: Implementación del protocollo Modelo Contexto de Anthropic para la integración con plataformas LLM como Claude Desktop.
2. Procesamiento Datos RAG: Proporciona funcionalidades como el descarga de documentos, la clasificación y el recuperar para apoyar las tareas RAG.
3. Sistema de Herramientas: Soporta vari herramientas entre las que se encuentran send_nonstream_chat, list_agents, list_buckets, y upload_document_by_file.
4. Gestión de Archivos: Permite operaciones como el descarga, el descarga y la eliminación de archivos para la gestión del sistema de archivos.
5. Integración API: Se conecta con la API REST de la plataforma Storm para proveer vari servicios.

Estructura del Proyecto

• main.py: Inicializa el servidor MCP y configura los manejadores de eventos.
• core/file_manager.py: Define la clase FileSystemManager para las operaciones de archivo.
• core/internal_api.py: Contiene funciones API cliente para la comunicación con la API REST de la plataforma Storm.
• tools/tool_definitions.py: Especifica las herramientas utilizadas por el servidor MCP.
• tools/tool_handlers.py: Implementa manejadores para variias operaciones de herramientas.
• tools/tool_upload_file.py: Proporciona un manejador y un servidor de archivo para los descargas de documentos.

Arquitectura

La arquitectura del MCP está estructurada en tres capas :

1. Anfitrión (Aplicación LLM): Una plataforma interactiva de IA donde los usuarios envían solicitudes y reciben respuestas.
2. Cliente (Implementación del Protocolo): Implementa el protocolo MCP y comunica con el anfitrión.
3. Servidor (Proveedor de Funcionalidades): Proporciona recursos y herramientas, gestionando varias tareas.

Inicio

Para iniciar el servidor MCP en una plataforma Claude Desktop, siga estos pasos :

1. Abre el Archivo de Configuración:

   code ~/Library/Application\ Support/Claude/claude_desktop_config.json
   

2. Agrega la Configuración del Servidor MCP:

   {
     "mcpServers": {
       "storm": {
         "command": "sh",
         "args": [
           "/Users/sigridjinet/Desktop/work/storm-mcp-server/scripts/run.sh"
         ]
       }
     }
   }
   

---

Português

Servidor Storm MCP (Modelo Contexto Protocollo)

O servidor Storm MCP é um protocolo open-source que permite uma interação fluida entre as aplicações de grandes modelos linguísticos (LLM) e as fontes de dados RAG, assim como as ferramentas. Implementando o Modelo Contexto Protocollo de Anthropic, pode ser utilizado em plataformas como Claude Desktop.

A plataforma Storm Platform de Sionic AI está construída sobre a tecnologia RAG, e este servidor pode se integrar com os serviços de Sionic AI para oferecer funções adicionais aos usuários. Com este servidor, é possível obter uma interação fluida entre os LLMs e os dados RAG, assim como apoiar vari ferramentas e operações de gestão de arquivos.

Principais Características

1. Suporte ao Protocollo Modelo Contexto: Implementação do protocollo Modelo Contexto de Anthropic para a integração com plataformas LLM como Claude Desktop.
2. Processamento Dados RAG: Fornece funcionalidades como o download de documentos, a classificação e o recuperar para apoiar as tarefas RAG.
3. Sistema de Ferramentas: Suporta vari ferramentas entre as quais se encontram send_nonstream_chat, list_agents, list_buckets, e upload_document_by_file.
4. Gestão de Arquivos: Permite operações como o download, o upload e a exclusão de arquivos para a gestão do sistema de arquivos.
5. Integração API: Se conecta com a API REST da plataforma Storm para fornecer vari serviços.

Estrutura do Projeto

• main.py: Inicializa o servidor MCP e configura os manipuladores de eventos.
• core/file_manager.py: Define a classe FileSystemManager para as operações de arquivo.
• core/internal_api.py: Contém funções API cliente para a comunicação com a API REST da plataforma Storm.
• tools/tool_definitions.py: Especifica as ferramentas utilizadas pelo servidor MCP.
• tools/tool_handlers.py: Implementa manipuladores para variias operações de ferramentas.
• tools/tool_upload_file.py: Fornece um manipulador e um servidor de arquivo para os downloads de documentos.

Arquitetura

A arquitetura do MCP está estruturada em três camadas :

1. Anfitrião (Aplicação LLM): Uma plataforma interativa de IA onde os usuários enviam solicitações e recebem respostas.
2. Cliente (Implementação do Protótipo): Implementa o protótipo MCP e comunica com o anfitrião.
3. Servidor (Fornecedor de Funcionalidades): Fornece recursos e ferramentas, gerenciando várias tarefas.

Início

Para iniciar o servidor MCP em uma plataforma Claude Desktop, siga esses passos :

1. Abra o Arquivo de Configuração:

   code ~/Library/Application\ Support/Claude/claude_desktop_config.json
   

2. Adicione a Configuração do Servidor MCP:

   {
     "mcpServers": {
       "storm": {
         "command": "sh",
         "args": [
           "/Users/sigridjinet/Desktop/work/storm-mcp-server/scripts/run.sh"
         ]
       }
     }
   }
   

---

Polski

Serwer Storm MCP (Model Context Protocol)

Serwer Storm MCP to protokół open-source, który pozwala nafluidną interakcję między aplikacjami wielkich modeli językowych (LLM) a zródłami danych RAG oraz narzędiami. Implementując Model Context Protocol od Anthropic, może być używany w platformach takich jak Claude Desktop.

Platforma Storm Platform od Sionic AI jest zbudowana na technologii RAG, a ten serwer może się integracjać z usługami Sionic AI, aby dostarczyć dodatkowe funkcje użytkownikom. Dzięki temu serweru można osiągnąć fluidną interakcję między LLM a danymi RAG, a także wspierać różne narzędzia i operacje na plikach.

Najważniejsze Carakterystyki

1. Obsługa Protocol Model Context: Implementacja protokołu Model Context od Anthropic dla integracji z platformami LLM takimi jak Claude Desktop.
2. Przetwarzanie Danych RAG: Dostarcza funkcjonalność do pobierania, sortowania i odtwarzania danych, aby wspierać zadania RAG.
3. System Nartędzia: Obsługa różnych narzędzi, w tym send_nonstream_chat, list_agents, list_buckets oraz upload_document_by_file.
4. Gestia Plików: Pozwala na operacje takie jak upload, download i usuwanie plików dla zarządzania systemem plików.
5. Integracja API: Łączy się z API REST platformy Storm, aby dostarczyć various usługi.

Struktura Projektu

• main.py: Inicjalizuje serwer MCP i konfiguruje obsługę zdarzeń.
• core/file_manager.py: Definiuje klasę FileSystemManager dla operacji na plikach.
• core/internal_api.py: Zawiera funkcje API klienta do komunikacji z API REST platformy Storm.
• tools/tool_definitions.py: Określa narzędzia używane przez serwer MCP.
• tools/tool_handlers.py: Implementuje obsługę różnych operacji na narzędziach.
• tools/tool_upload_file.py: Dostarcza manipulatorem i serwer do przesyłania plików.

Architektura

Architektura protokołu MCP składa się z trzech warstw :

1. Gospodarz (Aplikacja LLM): Interaktywna platforma AI, gdzie użytkownicy wysyłają żądania i otrzymują odpowiedzi.
2. Klient (Implementacja Protokołu): Implementuje protokół MCP i komunikuje się z gospodarzem.
3. Serwer (Dostawca Funkcjonalności): Dostarcza zasobów i narzędzi, zarządzając różnymi taskami.

Rozpocznij Użycie

Aby rozpocząć korzystanie z serwera MCP na platformie Claude Desktop, postępuj tak:

1. Otwórz plik konfiguracyjny:

   code ~/Library/Application\ Support/Claude/claude_desktop_config.json
   

2. Dopisz konfigurację serwera MCP:

   {
     "mcpServers": {
       "storm": {
         "command": "sh",
         "args": [
           "/Users/sigridjinet/Desktop/work/storm-mcp-server/scripts/run.sh"
         ]
       }
     }
   }
   

---

简体中文

飓风 MCP 服务器 (模型上下文协议)

飓风 MCP 服务器是一个开源协议，允许大型语言模型（LLM）与 RAG 数据源和工具之间进行流畅交互。通过实现 模型上下文协议 来自 Anthropic，它可以在 Claude Desktop 等平台上使用。

飓风平台 Storm Platform 由 Sionic AI 建立在 RAG 技术之上，而该服务器可以与 Sionic AI 的服务集成，以向用户提供额外功能。借助此服务器，您可以实现 LLM 和 RAG 数据之间的流畅交互，并支持各种文件工具和操作。

主要特点

1. 模型上下文协议支持：为 Claude Desktop 等平台上的 LLM 实现模型上下文协议。
2. RAG 数据处理：提供数据获取、排序和检索功能，以支持 RAG 任务。
3. 工具系统：支持多种工具，包括 send_nonstream_chat、list_agents、list_buckets 和 upload_document_by_file。
4. 文件管理：允许文件的上传、下载和删除操作，以便管理文件系统。
5. API 集成：与 Storm 平台的 REST API 集成，以提供各种服务。

项目结构

• main.py：初始化 MCP 服务器并配置事件处理。
• core/file_manager.py：定义 FileSystemManager 类用于文件操作。
• core/internal_api.py：包含客户端与 Storm 平台 REST API 通信的函数。
• tools/tool_definitions.py：定义 MCP 服务器使用的工具。
• tools/tool_handlers.py：实现对各种工具的操作处理。
• tools/tool_upload_file.py：提供文件上传的处理器和服务器。

架构

MCP 协议架构分为三层：

1. 主机（LLM 应用）：交互式 AI 平台，用户在此发送请求并接收响应。
2. 客户端（协议实现）：实现 MCP 协议并与主机通信。
3. 服务器（功能提供者）：提供资源和工具，管理各种任务。

开始使用

要在 Claude Desktop 上开始使用 MCP 服务器，请按照以下步骤操作：

1. 打开配置文件：

   code ~/Library/Application\ Support/Claude/claude_desktop_config.json
   

2. 添加 MCP 服务器配置：

   {
     "mcpServers": {
       "storm": {
         "command": "sh",
         "args": [
           "/Users/sigurðjóansson/Desktop/work/storm-mcp-server/scripts/run.sh"
         ]
       }
     }
   }
   

---

繁體中文

颶風 MCP 伺服器 (模型上下文協議)

颶風 MCP 伺服器是一種開源協議，允許大型语言模型（LLM）與 RAG 數據來源和工具之間進行流暢交互。通過實現 模型上下文協議 來自 Anthropic，它可以在 Claude Desktop 等平台上使用。

颶風平台 Storm Platform 由 Sionic AI 建立在 RAG 技術之上，而該伺服器可以與 Sionic AI 的服務集成，以向用戶提供額外功能。借助此伺服器，您可以實現 LLM 和 RAG 數據之間的流暢交互，並支持各種文件工具和操作。

主要特點

1. 模型上下文協議支援：為 Claude Desktop 等平台上的 LLM 實現模型上下文協議。
2. RAG 数据處理：提供數據獲取、排序和檢索功能，以支援 RAG 任務。
3. 工具系統：支持多種工具，包括 send_nonstream_chat、list_agents、list_buckets 和 upload_document_by_file。
4. 文件管理：允許文件的上傳、下載和刪除操作，以便管理文件系統。
5. API 集成：與 Storm 平台的 REST API 集成，以提供各種服務。

項目結構

• main.py：初始化 MCP 伺服器並配置事件處理。
• core/file_manager.py：定義 FileSystemManager 類用於文件操作。
• core/internal_api.py：包含客戶端與 Storm 平台 REST API 通信的函數。
• tools/tool_definitions.py：定義 MCP 伺服器使用的工具。
• tools/tool_handlers.py：實現對各種工具的操作處理。
• tools/tool_upload_file.py：提供文件上傳的处理器和伺服器。

架構

MCP 協議架構分為三層：

1. 主机（LLM 應用）：互動式 AI 平台，用戶在此發送請求並接收響應。
2. 客戶端（協議實現）：實現 MCP 協議並與主机通信。
3. 伺服器（功能提供者）：提供資源和工具，管理各種任務。

開始使用

要在 Claude Desktop 上開始使用 MCP 伺服器，請按照以下步驟操作：

1. 開啟配置文件：

   code ~/Library/Application\ Support/Claude/claude_desktop_config.json
   

2. 新增 MCP 伺服器配置：

   {
     "mcpServers": {
       "storm": {
         "command": "sh",
         "args": [
           "/Users/sigurðjóansson/Desktop/work/storm-mcp-server/scripts/run.sh"
         ]
       }
     }
   }
   

---

한국어

토판 MCP 서버 (모델 컨텍스트 프로토콜)

토판 MCP 서버는开源 프로토콜로, 대형 언어 모델(Large Language Model, LLM)이 RAG 데이터 원천과 도구와의 원활한 상호작용을 가능하게 합니다. Anthropic에서 제안한 모델 컨텍스트 프로토콜을 구현하여 Claude Desktop 등 플랫폼에서 사용할 수 있습니다.

토판 플랫폼 Storm Platform은 RAG 기술 위에 구축되고, 해당 서버는 Sionic AI의 서비스와 통합되어 사용자에게 추가 기능을 제공합니다. 이 서버를 통해 LLM과 RAG 데이터 간의 원활한 상호작용뿐만 아니라 다양한 파일 도구와 작업도 지원할 수 있습니다.

주요 특징

1. 모델 컨텍스트 프로토콜 지원：Claude Desktop 등의 플랫폼에서 LLM에 모델 컨텍스트 프로토콜을 구현합니다.
2. RAG 데이터 처리：데이터 획득, 정렬 및 검색 기능을 통해 RAG 작업을 지원합니다.
3. 도구 시스템：send_nonstream_chat, list_agents, list_buckets, upload_document_by_file 등의 다양한 도구를 지원합니다.
4. 파일 관리：문서의 업로드, 다운로드 및 삭제 작업을 통해 파일 시스템을 관리할 수 있습니다.
5. API 통합：Storm 플랫폼의 REST API와 통합하여 각종 서비스를 제공합니다.

구조

MCP 프로토콜은 아래 세 가지 계층으로 구성됩니다:

1. 호스트 (LLM 애플리케이션)：인터랙티브 AI 플랫폼으로, 사용자가 요청을 보내고 응답을 받는 곳입니다.
2. 클라이언트 (프로토콜 구현)：MCP 프로토콜을 구현하고 호스트와 통신합니다.
3. 서버 (기능 제공자)：리소урс와 도구를 제공하고 각종 작업을 관리합니다.

시작하기

Claude Desktop에서 MCP 서버를 사용하려면 아래 단계를 따르세요:

1. ** 설정 파일 열기**：

   code ~/Library/Application\ Support/Claude/claude_desktop_config.json
   

2. MCP 서버 설정 추가：

   {
     "mcpServers": {
       "storm": {
         "command": "sh",
         "args": [
           "/Users/sigurðjóansson/Desktop/work/storm-mcp-server/scripts/run.sh"
         ]
       }
     }
   }
   

---

Italiano

Tempesta MCP Server (Modello di Contesto Protocollo)

Il server MCP di Tempesta è un protocollo open-source che consente l'interazione fluida tra modelli LLM (Large Language Model) e fonti di dati RAG, nonché con vari tool. Attraverso l'implementazione del Protocollo di Contesto dei Modelli proposto da Anthropic, è possibile utilizzarlo su piattaforme come Claude Desktop.

La piattaforma Tempesta Storm Platform è costruita sulla tecnologia RAG e il server MCP vi si integrate per offrire ulteriori funzionalità all'utente. Attraverso questo server, è possibile avviare un dialogo fluido tra LLM e dati RAG, nonché gestire varie operazioni di file con diverse tool.

Caratteristiche principali

1. Supporto al Protocollo di Contesto dei Modelli：Implementazione del protocollo sulle piattaforme come Claude Desktop per i modelli LLM.
2. Processamento dati RAG：Funzionalità per l'acquisizione, ordinamento e recupero di dati RAG.
3. Sistema tool：Supporto a vari strumenti come send_nonstream_chat, list_agents, list_buckets, upload_document_by_file.
4. Gestione file：Operazioni di upload, download e cancellazione di documenti per la gestione del sistema di file.
5. Integrazione API：Integrazione con l'API REST della piattaforma Storm per offrire servizi vari.

Architettura

Il protocollo MCP è strutturato in tre livelli:

1. Host (Applicazione LLM)：Piattaforma interattiva di AI dove l'utente invia richieste e riceve risposte.
2. Cliente (Implementazione Protocollo)：Componente che implementa il protocollo MCP e comunica con l'host.
3. Server (Fornitore di Funzionalità)：Fornisce risorse e tool, gestisce operazioni diverse.

Inizio all'uso

Per avviare l'utilizzo del server MCP su Claude Desktop segui questi passaggi:

1. Apri il file di configurazione：

   code ~/Library/Application\ Support/Claude/claude_desktop_config.json
   

2. Aggiungi le impostazioni del server MCP：

   {
     "mcpServers": {
       "storm": {
         "command": "sh",
         "args": [
           "/Users/sigurðjóansson/Desktop/work/storm-mcp-server/scripts/run.sh"
         ]
       }
     }
   }
   

---

Portuguese

Tempesta MCP Server (Protocolo de Contexto do Modelo)

O servidor MCP da Tempesta é um protocolo open-source que permite interação fluida entre modelos LLM (Large Language Model) e fontes de dados RAG, além de ferramentas variadas. Com a implementação do Protocolo de Contexto do Modelo proposto pela Anthropic, é possível utilizá-lo em plataformas como o Claude Desktop.

A plataforma Tempesta Storm Platform é construída na tecnologia RAG e o servidor MCP se integra a ela para oferecer funcionalidades adicionais ao usuário. Por meio deste servidor, é possível estabelecer uma interação fluida entre LLM e dados RAG, além de gerenciar operações de arquivo com diferentes ferramentas.

Principais características

1. Suporte ao Protocolo de Contexto do Modelo：Implementação do protocolo em plataformas como Claude Desktop para os modelos LLM.
2. Processamento de dados RAG：Funções para aquisição, ordenação e recuperação de dados RAG.
3. Sistema de ferramentas：Suporte a variados tools como send_nonstream_chat, list_agents, list_buckets, upload_document_by_file.
4. Gestão de arquivos：Operações de upload, download e exclusão de documentos para a gestão do sistema de arquivos.
5. Integração com API：Integração com a API REST da plataforma Storm para oferecer serviços variados.

Arquitetura

O protocolo MCP é estruturado em três níveis:

1. Host (Aplicação LLM)：Plataforma interativa de IA onde o usuário envia solicitações e recebe respostas.
2. Cliente (Implementação do Protocolo)：Componente que implementa o protocolo MCP e comunica com o host.
3. Server (Fornecedor de Funcionalidades)：Fornece recursos e ferramentas, gerencia operações variadas.

Começando a usar

Para iniciar o uso do servidor MCP no Claude Desktop, siga这些passos:

1. Abra o arquivo de configuração：

   code ~/Library/Application\ Support/Claude/claude_desktop_config.json
   

2. Adicione as configurações do servidor MCP：

   {
     "mcpServers": {
       "storm": {
         "command": "sh",
         "args": [
           "/Users/sigurðjóansson/Desktop/work/storm-mcp-server/scripts/run.sh"
         ]
       }
     }
   }
   

---

Spanish

Tormenta MCP Server (Protocolo de Contexto del Modelo)

El servidor MCP de Tormenta es un protocolo open-source que permite una interacción fluida entre los modelos LLM (Large Language Model) y las fuentes de datos RAG, además de herramientas variadas. A través de la implementación del Protocolo de Contexto del Modelo propuesto por Anthropic, es posible utilizarlo en plataformas como Claude Desktop.

La plataforma Tormenta Storm Platform está construida sobre la tecnología RAG y el servidor MCP se integra con ella para ofrecer funcionalidades adicionales al usuario. A través de este servidor, es posible establecer una interacción fluida entre LLM y datos RAG, además de gestionar operaciones de archivo con diferentes herramientas.

Características principales

1. Soporte al Protocolo de Contexto del Modelo：Implementación del protocolo en plataformas como Claude Desktop para los modelos LLM.
2. Procesamiento de datos RAG：Funcionalidades para la adquisición, ordenamiento y recuperación de datos RAG.
3. Sistema de herramientas：Soporte a variadas herramientas como send_nonstream_chat, list_agents, list_buckets, upload_document_by_file.
4. Gestión de archivos：Operaciones de subida, descarga y eliminación de documentos para la gestión del sistema de archivos.
5. Integración con API：Integración con la API REST de la plataforma Storm para ofrecer servicios variados.

Arquitectura

El protocolo MCP está estructurado en tres niveles:

1. Host (Aplicación LLM)：Plataforma interactiva de IA donde el usuario envía solicitudes y recibe respuestas.
2. Cliente (Implementación del Protocolo)：Componente que implementa el protocolo MCP y se comunica con el host.
3. Servidor (Proveedor de Funcionalidades)：Suministra recursos y herramientas, gestiona operaciones variadas.

Comenzando a usar

Para comenzar a utilizar el servidor MCP en Claude Desktop, siga estos pasos:

1. Abre el archivo de configuración：

   code ~/Library/Application\ Support/Claude/claude_desktop_config.json
   

2. Agregue las configuraciones del servidor MCP：

   {
     "mcpServers": {
       "storm": {
         "command": "sh",
         "args": [
           "/Users/sigurðjóansson/Desktop/work/storm-mcp-server/scripts/run.sh"
         ]
       }
     }
   }
   

---

French

Tempête MCP Server (Protocole de Contexte du Modèle)

Le serveur MCP de la Tempête est un protocole open-source qui permet une interaction fluide entre les modèles LLM (Large Language Model) et les sources de données RAG, ainsi que des outils variés. À travers l'implémentation du Protocole de Contexte du Modèle proposé par Anthropic, il est possible de l'utiliser sur des plateformes comme Claude Desktop.

La plateforme Tempête Storm Platform est construite sur la technologie RAG et le serveur MCP seintègre avec elle pour offrir des fonctionnalités supplémentaires à l'utilisateur. À travers ce serveur, il est possible d'établir une interaction fluide entre LLM et données RAG, ainsi que de gérer les opérations de fichiers avec des outils différents.

Principales caractéristiques

1. Support du Protocole de Contexte du Modèle：Implémentation du protocole sur des plateformes comme Claude Desktop pour les modèles LLM.
2. Traitement des données RAG：Fonctionnalités pour l'acquisition, le tri et la récupération des données RAG.
3. Système d'outils：Support de variés outils comme send_nonstream_chat, list_agents, list_buckets, upload_document_by_file.
4. Gestion des fichiers：Opérations d'envoi, téléchargement et suppression de documents pour la gestion du système de fichiers.
5. Intégration avec l'API：Intégration avec l'API REST de la plateforme Storm pour offrir des services variés.

Architecture

Le protocole MCP est structuré en trois niveaux :

1. Hôte (Application LLM)：Plateforme interactive d'IA où l'utilisateur envoie les requêtes et reçoit les réponses.
2. Client (Implémentation du Protocole)：Composant qui implémente le protocole MCP et se communique avec l'hôte.
3. Serveur (Fournisseur de Fonctionnalités)：Fournit des ressources et outils, gère les opérations variées.

Commencer à utiliser

Pour commencer à utiliser le serveur MCP sur Claude Desktop, suivez ces étapes :

1. Ouvrez le fichier de configuration：

   code ~/Library/Application\ Support/Claude/claude_desktop_config.json
   

2. Ajoutez les configurations du serveur MCP：

   {
     "mcpServers": {
       "storm": {
         "command": "sh",
         "args": [
           "/Users/sigurðjóansson/Desktop/work/storm-mcp-server/scripts/run.sh"
         ]
       }
     }
   }
   

---

Japanese

颚嵂 MCP サーバー (モデル コンテキスト プロトコル)

MCP（Model Context Protocol）は、大規模言語モデル（LLM）とRAGデータソースとの間の通信を可能にするオープンソースプロトコルです。この文書では、MCPサーバーである「颚嵂」の概要、特徴、およびセットアップ方法について説明します。

概要

• 目的: LLMとRAGデータソース間の通信を仲介し、双方の利点を活用して高度なタスク処理を可能にします。
• 主要機能:
  • RAGデータソースからの情報検索
  • 検索結果に基づくLLMの推論補助
  • 安全性と効率性の高い通信

特徴

1. 高性能: 高速なデータ処理と通信を実現。
2. 拡張性: 複数のRAGソースやLLMとの統合が可能です。
3. 安全性: 機密情報保護のために安全な通信プロトコルを採用。
4. ユーザー フriendly: インターフェースが直感的で操作が容易。

MCPサーバーのセットアップ

必要条件

• オペレーティングシステム: Linux, macOS, Windows（推奨: Linux）
• 依存関係: Python 3.8以上、必要ないPLEMENTARY_LIBS
• ダウンロード: 公式リポジトリからダウンロード。

インストール手順

1. リポジトリのクローン:

   git clone https://github.com/your-repository.git
   cd mcp-server
   

2. 依存関係のインストール:

   pip install -r requirements.txt
   

3. サーバー起動:

   python main.py
   

設定ファイル

{
  "mcp_servers": {
    "storm": {
      "command": "sh",
      "args": [
        "/Users/sigurðjóansson/Desktop/work/storm-mcp-server/scripts/run.sh"
      ]
    }
  }
}

安全性とプライバシー

• 認証: APIキーまたはトークンを使った認証をサポート。
• データ保護: 機密情報の暗号化通信。

メリット

• 生産性向上: 高速な情報検索と推論が可能。
• 柔軟性: 複数のソースやモデルとの連携が容易。
• コスト効率: リソース使用効率が高く、スケーラビリティに優れる。

トラブルシューティング

• 接続エラー: 端口番号やホスト名の確認。
• 性能劣化: バッファサイズ調整やワークロード分散を検討。
• セキュリティ問題: 認証トークンの有効期限管理。

関連リンク

• 公式ホームページ
• GitHubリポジトリ
• ドキュメント

---

German

Sturm MCP-Server (Modell Kontext Protokoll)

MCP（Model Context Protocol） ist ein Open-Source-Protokoll, das die Kommunikation zwischen großen Sprachmodellen (LLM) und RAG-Datensources ermöglicht. Dieses Dokument gibt eine Übersicht über den MCP-Server namens "Sturm", seine Funktionen, sowie Anweisungen zur Einrichtung.

Zusammenfassung

• Ziel: Die Vermittlung der Kommunikation zwischen LLM und RAG-Datensources, um die Vorteile beider Seiten zu nutzen und anspruchsvolle Aufgabenbearbeitung zu ermöglichen.
• Hauptmerkmale:
  • Informationserkundung in RAG-Datensourcen
  • Deduktion von Suchergebnissen zur Unterstützung der LLM-Inferenz
  • Sicherheits- und Effizienz-Promotion

Eigenschaften

1. Hohe Leistung: Schnelle Datverarbeitung und Kommunikation.
2. Erweiterbarkeit: Integration mit mehreren RAG-Quellen oder LLMs.
3. Sicherheit: Sicherheitsprotokolle für vertrauliche Datenübermittlung.
4. Benutzer-freundlichkeit: Intuitives Interface, einfache Bedienung.

Einrichtung des MCP-Servers

Voraussetzungen

• Betriebssystem: Linux, macOS, Windows (empfohlen: Linux)
• Abhängigkeiten: Python 3.8 oder höher, notwendige BIBLIOTEKANES.
• Herunterladen: Offizielle Repositorium herunterladen.

Installationsanweisungen

1. Repository klonen:

   git clone https://github.com/iyer-repository.git
   cd mcp-server
   

2. Abhängigkeiten installieren:

   pip install -r requirements.txt
   

3. Server starten:

   python main.py
   

Konfigurationsdatei

{
  "mcp_servers": {
    "storm": {
      "command": "sh",
      "args": [
        "/Users/sigurðjóansson/Desktop/work/storm-mcp-server/scripts/run.sh"
      ]
    }
  }
}

Sicherheit und Privatsphäre

• Authentizierung: Unterstützt Authentisierung über API-Schlüssel oder Tokens.
• Daten schutz: Verschlüsselte Communication für vertrauliche Daten.

Vorteile

• Produktivitätserhöhung: Schnelle Informationserkundung und Deduktion ermöglichen.
• FleXIBILITÄT: Leichte Integration mit verschiedenen Quellen oder Modellen.
• Kosteneffizienz: Ressourcenverwaltungseffizienz und Skalierbarkeit.

Troubleshooting

• Verbindungsfehler: Kontrolle der Portnummer oder des Hostnamens.
• Leistungsminderung: Anpassen des Buffersizes oder Lastausgleich überprüfen.
• Sicherheitsprobleme: Token-Zeitlimit Management.

Verweisen

• Offizielle Homepage
• GitHub Repositorium
• Dokumentation

---

Storm MCP Server Documentation

Welcome to the documentation for the Storm MCP Server, designed to facilitate communication between large language models (LLMs) and RAG data sources. This guide provides an overview of the server's features, setup instructions, and configuration details.

Overview

What is MCP?

MCP stands for Model Context Protocol. It is a protocol that enables communication between LLMs and RAG data sources, allowing them to collaborate effectively on complex tasks.

Key Features

• Efficient Communication: Enables seamless interaction between LLMs and RAG systems.
• Enhanced Capabilities: Combines the strengths of both LLMs and RAG systems for better task execution.
• Flexibility: Supports integration with multiple RAG sources and various LLMs.

Setup Guide

Prerequisites

Before setting up the Storm MCP Server, ensure you have the following:

1. Operating System: Linux, macOS, or Windows (Linux is recommended).
2. Python Version: Python 3.8 or higher.
3. Dependencies: Ensure all necessary libraries are installed.

Installation Steps

1. Clone the Repository:

   git clone https://github.com/your-repository.git
   cd mcp-server
   

2. Install Dependencies:

   pip install -r requirements.txt
   

3. Run the Server:

   python main.py
   

Configuration

The server can be configured using a JSON file:

{
  "mcp_servers": {
    "storm": {
      "command": "sh",
      "args": [
        "/Users/sigurðjóansson/Desktop/work/storm-mcp-server/scripts/run.sh"
      ]
    }
  }
}

Security and Privacy

• Authentication: Use API keys or tokens for secure access.
• Data Protection: Implement encrypted communication channels.

Benefits

• Improved Productivity: Facilitates efficient collaboration between LLMs and RAG systems.
• Enhanced Flexibility: Supports multiple configurations and integrations.
• Cost Efficiency: Optimizes resource usage and enhances scalability.

Troubleshooting

Common issues include connection errors, performance bottlenecks, and security concerns. For detailed troubleshooting steps, refer to the Troubleshooting Guide.

References

For further information, please visit:

• Storm MCP Server Homepage
• GitHub Repository
• Comprehensive Documentation

Storm MCP Server Documentation

Welcome to the documentation for the Storm MCP Server. This guide provides an overview of the server's features, setup instructions, and configuration details.

Overview

What is MCP?

MCP (Model Context Protocol) is a protocol designed to facilitate communication between large language models (LLMs) and RAG (Retrieval-Augmented Generation) data sources. It allows for effective collaboration between these systems on complex tasks.

Key Features

• Efficient Communication: Enables seamless interaction between LLMs and RAG systems.
• Enhanced Capabilities: Leverages the strengths of both LLMs and RAG systems to improve task execution.
• Flexibility: Supports integration with multiple RAG sources and various LLM providers.

Setup Guide

Prerequisites

Before setting up the Storm MCP Server, ensure you have the following:

1. Operating System: Linux, macOS, or Windows (Linux is recommended).
2. Python Version: Python 3.8 or higher.
3. Dependencies: Make sure all required libraries are installed.

Installation Steps

1. Clone the Repository:

   git clone https://github.com/your-repository.git
   cd mcp-server
   

2. Install Dependencies:

   pip install -r requirements.txt
   

3. Run the Server:

   python main.py
   

Configuration

The server can be configured using a JSON file:

{
  "mcp_servers": {
    "storm": {
      "command": "sh",
      "args": [
        "/Users/sigurðjóansson/Desktop/work/storm-mcp-server/scripts/run.sh"
      ]
    }
  }
}

Security and Privacy

• Authentication: Secure access can be managed using API keys or tokens.
• Data Protection: Encrypted communication channels are recommended for data security.

Benefits

• Improved Productivity: Facilitates efficient collaboration between LLMs and RAG systems, enhancing task performance.
• Enhanced Flexibility: Supports multiple configurations and integrations to suit various needs.
• Cost Efficiency: Optimizes resource usage and enhances scalability, leading to cost-effective operations.

Troubleshooting

Common issues may include connection errors, performance bottlenecks, and security concerns. For detailed troubleshooting steps, refer to the Troubleshooting Guide.

References

For further information, please visit:

• Storm MCP Server Homepage
• GitHub Repository
• Comprehensive Documentation