Está se tornando actual aqui.
Desde que compartilhei como os agentes de IA autônomos podem monitorar e curar a rede por conta própria –Sim, esse-Eu recebi a mesma pergunta de acompanhamento de diferentes formas:
“Okay, Kareem, tudo isso parece ótimo … mas como eu na verdade Construa um desses servidores de protocolo de contexto de modelo (MCP) para o meu produto? ”
Boas notícias! Se o seu produto – como quase todos os produtos por aí – tem APIs, é provável que você já tenha o que precisa.
Digite: OpenApi Spec
O OpenAPI é um contrato amigável para suas APIs. Você pode ter usado para Docs Swagger, SDKs, Coleções de Postman, ou aquele projeto empoeirado CodeGen de 2021. Mas aqui está a reviravolta: E se você passou a mesma especificação do OpenAPI para o seu agente de IA?
É isso. Essa é a chave.
One OpenApi Spec → One MCP Server → Um gateway de acesso a IA e acessar o seu produto.
E não, esta não é uma situação de “12 etapas e uma devrel milagrosa”. São apenas algumas linhas de Python e um invólucro rápido em torno do seu arquivo OpenAPI. A magia? Suas APIs são transformadas em ferramentas de AI seguras e baseadas em funções-sem escrever uma única definição de ferramenta personalizada.
Considere o seguinte exemplo:
Você está envolvendo sua especificação OpenAPI existente com o FastMCP, a fiação em seu cliente autenticado e passando no seu ACLS baseado em rotas. É assim que é simples ir de “API Docs” para “AI-Pronto, servidor MCP controlado por acesso”.
Construa rápido, governe inteligente
Neste novo mundo movido a IA, a velocidade é a parte mais fácil. Governança – esse é o elevador mais difícil.
Não queremos dar ao agente as chaves ao reino. Queremos fornecer um crachá com apenas o acesso adequado.
É aí que Routemap entra – o nosso ACLS para a IA. Com uma lista simples de padrões (regex para quem gosta de dor e sofrimento) e verbos HTTP, você pode declarar quais pontos de extremidade são acessíveis para diferentes personas (NOC, Sysadmin, acesso whole e assim por diante).
Sim, é literalmente tão fácil. Você está construindo ACLs de extremidade como código. Você não precisa criar um novo sistema de autenticação ou treinar um modelo para “aprender” as permissões. Você apenas declarar Quais funções obtêm acesso a quais pontos de extremidade – e o servidor MCP a aplica.
De caos para Order
Vamos percorrer um caso de uso do mundo actual.
Digamos que você seja uma equipe da NOC gerenciando uma implantação de Meraki de vários websites. Você é responsável por manter os dispositivos de rede corrigidos e seguros – mas não pode simplesmente agendar atualizações de firmware a qualquer momento. Alguns websites são 24/7. Algum pico ao meio -dia. Alguns turnos noturnos. A janela very best de atualização é um alvo em movimento.
É aí que o agente entra.
Você quer dar acesso ao agente apenas para ajudar:
- Puxe o standing atual do firmware
- Monitorar padrões de uso da rede
- Agenda atualizações Quando faz sentido
Enquanto isso, sua equipe de sysadmin precisa do agente para gerar relatórios de conformidade. Eles precisam saber quais dispositivos estão executando firmware desatualizado – mas não estão agendando atualizações ou tocando o tráfego ao vivo.
Duas personas. Dois escopos muito diferentes. Um servidor MCP.
Aqui está a beleza de tudo. Não escrevemos nenhuma ferramenta personalizada. Não construímos fluxos de trabalho ou lógica de negócios de codificação. Acabamos de alimentar o servidor MCP a especificação completa do Meraki OpenAPI – e Let Routemap lidar com o resto:
O agente NOC pode agendar atualizações, porque precisa desse controle. O agente de sysadmin? Ele recebe uma visualização somente leitura, adaptada para visibilidade e conformidade.
E novamente – não contamos ao agente como fazer qualquer coisa. A mágica está no servidor MCP. As ferramentas ficam disponíveis com base na função e a IA descobre o restante.
Esse é o tipo de autonomia governada que transforma a IA de um risco em uma capacidade.
Veja isso em ação
Como sempre, você encontrará tudo o que estou mostrando aqui – o código do servidor MCP, a configuração e o rápido – em Meu repo Github.
Agora vamos demitir isso. (E, sim, o faraó de rede é uma coisa agora.)
Com o servidor MCP em execução e nossos mapas de rota definidos, inicio o Claude Desktop (meu cliente MCP de escolha) e digito o seguinte immediate:
Seu nome é faraó de rede. Você está agindo com visibilidade administrativa completa e privilégios de acesso a dados. Você é um administrador sênior de rede que supervisiona várias organizações da Cisco Meraki em toda a empresa. Sua função é garantir que todos os dispositivos de rede estejam executando o firmware compatível mais recente. Você está autorizado a recomendar atualizações de firmware, mas deve aguardar a aprovação humana explícita antes de iniciar quaisquer atualizações.
Organizações -alvo: Cisco U.
Instruções de tarefas – Para cada organização:
- Liste todas as redes
- Para cada rede, liste todos os dispositivos associados (incluindo modelo, serial e versão de firmware atual)
- Recupere as recomendações de atualização de firmware disponíveis para a organização
- Identificar Qualquer dispositivo que não esteja executando a versão recomendada
- Recomendar atualizações de firmware conforme apropriado
- Não execute nenhuma atualização, a menos que o humano confirme explicitamente com uma declaração como: “Sim, atualize (dispositivo/rede).”
Vale a pena chamar algumas coisas:
O humano no loop é construído. O agente sabe disso não pode aja por conta própria – ele deve aguardar a aprovação. Isso é a governança assada no immediate.
Não dissemos ao agente como verificar a conformidade ou sugerir atualizações. Ele usa as ferramentas disponíveis no servidor MCP e atua dentro dos limites definidos por sua função.
O agente está fazendo um trabalho inteligente dentro de limites seguros – usando apenas O que recebeu acesso. Sem adivinhação. Sem raspagem. Nenhuma chamada de API não controlada. Apenas interação limpa e orientada por políticas através de uma interface estruturada e segura.
Aqui está a aparência da configuração do servidor MCP nos bastidores:
Preste atenção à importância do MCP_ROLE. Essa variável de ambiente controla o que o agente tem acesso. Defina -o como “NOC” e o agente pode recomendar atualizações de firmware. Defina -o como “Sysadmin” e o mesmo agente, com o mesmo immediate, só poderá gerar relatórios de conformidade – sem atualizações, sem postos.
Essa é a vantagem de separar a inteligência (LLM) do plano de controle (MCP). Você fica encarregado do que o agente pode fazer.
E aqui está o que o servidor MCP faz acontecer:
- A rede Pharaoh atravessa nossa organização Cisco U., puxando uma lista de dispositivos gerenciados e cuspindo um relatório.
- Como a rede Faraó está aguardando um humano no loop executar a atualização, ele também corra automaticamente a versão com base na pesquisa da net e a agenda para nós com base no uso.
- ET, pronto!
As habilidades nos bastidores
Vamos aumentar o zoom por um segundo. O que foi necessário para construir isso?
Aqui estão as habilidades um Engenheiro de rede precisa montar isso:
- Compreensão dos Fundamentos da API: Especificações OpenAPI, pontos de extremidade, métodos HTTP
- Script Python: Girando um servidor básico e configurando o wrapper MCP
- Controle de acesso Pensamento: Definir papéis, limites de acesso e aplicar menos privilégio
- Mentalidade de design do agente: Solicitando com contexto, propósito e supervisão humana clara
- Curiosidade e experimentação: Tentando as coisas e ajustes enquanto você vai
E talvez o mais importante:
- Uma mudança no pensamento – da automação de construção para a rede, para construir automação isso entende a rede.
Vamos continuar empurrando essa fronteira. Porque quanto mais construímos limites inteligentesquanto mais desbloqueamos autonomia segura.
E é assim que saímos do oeste selvagem … para uma empresa bem-governada de IA.
Inscreva -se para Cisco U. | Junte -se aoCisco Studying Community hoje de graça.
Aprenda com a Cisco
X|Tópicos| Fb|LinkedIn|Instagram|YouTube
Usar #Ciscou e#CiscocertPara participar da conversa.
Leia mais da série AI Break:
Compartilhar: