Resumo
Using an MCP server that integrates with FlashBlade allows you to query system data and even take direct actions, unlocking a new frontier in agentic storage management.
O gerenciamento do armazenamento local tem sido tradicionalmente um processo tedioso e manual: consultar métricas do sistema, monitorar o desempenho e executar ações muitas vezes exigem scripts complexos ou ferramentas especializadas. Mas e se você pudesse simplesmente pedir as informações necessárias em inglês simples e obter insights imediatos e acionáveis?
É aí que entra o Protocolo de Contexto Modelo (MCP, Model Context Protocol). O MCP é um protocolo aberto que permite que grandes modelos de linguagem (LLMs, Large Language Models) interajam de maneira inteligente com aplicativos, trazendo recursos de linguagem natural para o gerenciamento de armazenamento. Neste blog, mostraremos como criar um servidor MCP que se integre ao FlashBlade® da Pure Storage®, permitindo consultar dados do sistema e até mesmo tomar ações diretas, tudo por meio de uma interface intuitiva e com inteligência AI.
Ao modular nossa abordagem, estamos desbloqueando uma nova fronteira no gerenciamento de armazenamento agenteico, onde a automação não é apenas eficiente, mas também conversacional e adaptável. Vamos nos aprofundar.
Nosso objetivo para essas ações é um array da Pure Storage, especificamente um sistema FlashBlade, mas os princípios também são aplicáveis aos sistemas FlashArray. Usando o aplicativo de desktop Claude, nossas consultas usarão as ferramentas fornecidas pelo servidor MCP para interagir com o array designado da Pure Storage de acordo com esta captura de tela:
Criação de um servidor MCP
A primeira etapa é instalar o gerenciador de pacotes Python uv. Para obter instruções de instalação, consulte o guia oficial.
Em seguida, precisamos criar a estrutura do servidor MCP. Para isso, usaremos as ferramentas fornecidas no pacote uv:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
% uvx create–mcp–server Creating a new MCP server project using uv. This will set up a Python project with MCP dependency. Let‘s begin! Project name (required): pure–mcp–server Project description [A MCP server project]: A MCP server to retrieve realtime information from a Pure Storage FlashBlade Project version [0.1.0]: Project will be created at: /Users/jthomas/mcp/pure–mcp–server Is this correct? [Y/n]: Y .... Claude.app detected. Would you like to install the server into Claude.app now? [Y/n]: Y ✅ Added pure–mcp–server to Claude.app configuration Settings file location: /Users/jthomas/Library/Application Support/Claude/claude_desktop_config.json ✅ Created project pure–mcp–server in pure–mcp–server ℹ️ To install dependencies run: cd pure–mcp–server uv sync —dev —all–extras |
Prossiga com as etapas finais indicadas para instalar as dependências e nosso servidor MCP do esqueleto está pronto. O código-fonte que precisamos modificar está localizado em pure-mcp-server/src/pure-mcp-server. Neste ponto, o código é para uma ferramenta de notas adicionais de modelo. Modificaremos isso para interagir com um array FlashBlade da Pure Storage no local.
Na pasta do projeto, entramos no ambiente virtual Python que foi criado automaticamente pelo uv e instalamos o SDK Python da Pure Storage, pois aproveitaremos isso para interagir com a API REST do FlashBlade.
|
1 2 |
% source .venv/bin/activate (pure–mcp–server) % uv pip install py–pure–client |
Em seguida, adicionamos o código relevante para criar duas ferramentas de MCP para executar consultas em relação aos endpoints de um determinado array FlashBlade:
- get_arrays
- get_arrays e get_arrays_performance
O servidor MCP foi adicionado automaticamente à área de trabalho Claude durante a fase de inicialização. Para verificar, abra o seguinte arquivo e verifique se a entrada está correta:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
cat /Users/jthomas/Library/Application\ Support/Claude/claude_desktop_config.json { “mcpServers”: { “pure-mcp-server”: { “command”: “uv”, “args”: [ “–directory”, “/path/to/folder/pure-mcp-server”, “run”, “pure-mcp-server” ] } } } |
Além do inspetor do MCP, usamos o seguinte script para validar:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
import asyncio from mcp.client.session import ClientSession from mcp.client.stdio import StdioServerParameters, stdio_client async def main(): async with stdio_client( StdioServerParameters(command=“uv”, args=[“–directory”, “/Users/jthomas/mcp/pure-mcp-server”, “run”, “pure-mcp-server”]) ) as (read, write): async with ClientSession(read, write) as session: await session.initialize() # List available tools tools = await session.list_tools() print(tools) # Call the fetch tool result = await session.call_tool(“get-array”, {“host”: “1.2.3.4”, “api_token”: “T-da03****1a98”}) print(result) asyncio.run(main()) |
Esse código lista corretamente minhas ferramentas de servidor MCP. Ele também se conecta ao array remoto, realiza a chamada de API necessária e retorna a sequência JSON relevante.
Agora, por meio do aplicativo de desktop Claude, podemos executar consultas usando as ferramentas do servidor MCP em um determinado FlashBlade da Pure Storage:
E com a ferramenta get-array-full, pergunte sobre espaço de armazenamento:
Observe que essa é uma matriz de laboratório bastante ociosa, mas perguntas de acompanhamento podem ser feitas, como:
“Crie um gráfico para mostrar o desempenho dos últimos 7 dias com base no valor do tempo de época por métrica. Converta os resultados de desempenho da época e do grupo por dia.”
Execução de uma ferramenta modular de MCP
Até agora, o código fornece integração básica para chamadas codificadas de acordo com a definição da ferramenta do servidor MCP, mas podemos enviar ações e recuperar informações. Ter uma ferramenta de MCP por solicitação não é uma abordagem desejável. Precisamos mudar de uma chamada de API REST codificada get_arrays para uma abordagem modular, em que ela aceite qualquer chamada de endpoint como parâmetro por meio de uma única ferramenta pure-fb para usar em qualquer endpoint.
O código completo pode ser encontrado neste repositório do GitHub.
Uso
Com nosso novo servidor MCP em vigor, podemos executar consultas informativas, como:
“Use pure-fb no host: 1.2.3.4 com api-token: T-7c7a*****f23e para executar o comando: get_file_systems e, em seguida, o comando: get_buckets. Classifique os itens por tamanho usado e indique para cada um se é um bucket marcando o item como ‘s3’ ou um sistema de arquivos marcando o item como ‘fs’. Certifique-se de classificar corretamente em ordem decrescente com base no tamanho usado e liste os 5 principais por espaço usado.”
Isso resulta na seguinte saída:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
I‘ll help you retrieve and analyze the file systems and buckets information from your FlashBlade. View result from pure–fb from pureflashblade (local){} View result from pure–fb from pureflashblade (local){} Here are the top 5 storage items (combining both file systems and buckets) sorted by used space in descending order: lbo–outscale–perfs [fs]: 7,240,575,042,227 bytes (7.24 TB) lbo–vertica [fs]: 3,311,892,804,361 bytes (3.31 TB) dm [fs]: 2,213,617,471,583 bytes (2.21 TB) lbo–hdf5 [fs]: 1,643,315,388,928 bytes (1.64 TB) eg–px–share01 [fs]: 869,598,847,641 bytes (869.6 GB) As we can see, the top 5 spots are all occupied by file systems, with the largest being lbo–outscale–perfs at 7.24 TB. For reference, the largest bucket (cvlt–uklab–object–lock at 265.1 GB) would rank much lower in this combined list. |
Com essa abordagem modular, podemos consultar qualquer endpoint (obter arrays, buckets, sistemas de arquivos, etc.) para recuperar informações e tomar ações no array. Por exemplo, executaremos um comando simples de criar bucket usando a seguinte consulta:
“Use pure-fb no host: 1.2.3.4 com api-token: T-7c7a*****f23e e o comando post_buckets com os parâmetros: names=[“jbtmcptest”], bucket=BucketPost(account=Reference(name=’jbt’)) ”
No array FlashBlade da Pure Storage, podemos ver que o bucket relevante está presente agora:
Com essa consulta, criamos um sistema de arquivos. Observe que, neste exemplo, não fornecemos o endpoint específico. Deixamos isso para o LLM descobrir:
“Crie um sistema de arquivos usando os seguintes parâmetros: names=[“jbt-myfs”], file_system=FileSystemPost(provisioned=5000, hard_limit_enabled=True, nfs=Nfs(v4_1_enabled=True), smb=Smb(enabled=True), multi_protocol=MultiProtocolPost(access_control_style=”nfs”))”
Podemos ver que a ClaudeAI conseguiu fornecer o comando correto post_file_system para executar essa solicitação.
Definindo o prompt para agir como agente
Agora vamos adicionar algum contexto ao chat e definir o comportamento e os recursos de um agente de armazenamento que tem dois arrays para controlar:
“Você é um agente de gerenciamento de armazenamento inteligente que, por meio da ferramenta pure-fb, pode gerenciar os dois arrays a seguir:
array01 no host: 1.2.3.4 com api-token: T-7c7a*****f23e
array02 no host: 1.2.3.5 com api-token: T-f2e0*****3b8d”
Com esse agente de armazenamento definido, podemos executar consultas em ambos os arrays, como:
“Obtenha todos os buckets de ambos os arrays, extraia o nome, o total_used espaço bruto e o array de origem em uma única lista. Classifique estritamente com base nos total_used valores brutos sem conversões. Forneça os 15 principais da lista e converta o espaço usado em unidades apropriadas para exibição.”
Nosso agente começa coletando os dados relevantes usando get_buckets e get_file_systems contra os dois arrays:
O agente classifica os blocos por espaço usado conforme solicitado. Observe que foram necessárias várias tentativas para obter a solicitação para que a classificação fosse correta.
Desde o gerenciamento de armazenamento orientado por CLI até o assistido por AI
Com um servidor MCP, transformamos o gerenciamento de armazenamento local de um processo rígido e orientado por linha de comando em uma experiência de linguagem natural assistida por AI. Ao unir os LLMs ao armazenamento corporativo, não estamos mais apenas recuperando dados, estamos comandando nossa infraestrutura dinamicamente, reduzindo a complexidade e abrindo as portas para fluxos de trabalho mais inteligentes e eficientes.
Mas isso é apenas o começo. A automação agenteica está remodelando a tecnologia corporativa, e o armazenamento não é exceção. À medida que esses recursos evoluem, estamos avançando para um futuro em que o gerenciamento de armazenamento orientado por AI não é apenas uma conveniência, mas uma vantagem competitiva. A questão não é se isso se tornará o novo padrão: é em quanto tempo.
Você está pronto para dar o próximo passo?
Free Test Drive
Explore FlashBlade in our virtual lab.
