# MCP para fabricantes: um guia prático

> O que é o Model Context Protocol, o que um servidor MCP de peças deve expor, como o OAuth protege preço e estoque e quais assistentes conseguem alcançá-lo.

**Language:** pt  
**Published:** 2026-08-09  
**Category:** Technical · **Tags:** MCP, Model Context Protocol, OAuth, Streamable HTTP, parts data, AI agents  
**Canonical:** https://partsgraph.ai/pt/blog/mcp-for-manufacturers

## Em resumo

**O que é MCP e o que o servidor MCP de um fabricante deve expor?**

O MCP (Model Context Protocol) é um padrão aberto que permite a um assistente de IA chamar os seus sistemas diretamente, em vez de inferir respostas a partir das suas páginas web. O servidor MCP de um fabricante é um endpoint HTTP hospedado que expõe um pequeno conjunto de ferramentas tipadas — busca paramétrica, consulta de peças, alternativas e referências cruzadas, documentos de conformidade, links de CAD e estoque e preços protegidos por OAuth — que qualquer assistente compatível pode invocar para obter uma resposta exata e auditável. Sob a especificação atual, 2026-07-28, é um serviço stateless de requisição/resposta que roda atrás de um balanceador de carga comum. O protocolo é a parte fácil; a parte difícil é ter, por trás dele, um único registro de produto canônico e verificado.

---

## O que é MCP, em termos simples?

O Model Context Protocol é uma forma padronizada de um assistente de IA chamar o sistema de outra empresa e receber de volta uma resposta tipada e estruturada.

A Anthropic abriu o código em 25 de novembro de 2024, descrevendo-o como "um novo padrão para conectar assistentes de IA aos sistemas onde os dados vivem". Em 9 de dezembro de 2025, a Anthropic doou o MCP à Agentic AI Foundation, um fundo dirigido dentro da Linux Foundation, cofundado com Block e OpenAI e apoiado em nível platina por AWS, Bloomberg, Cloudflare, Google e Microsoft. Naquele momento, o MCP já havia ultrapassado 97 milhões de downloads mensais de SDK e mais de 10.000 servidores publicados, com suporte de cliente de primeira classe em ChatGPT, Claude, Cursor, Gemini, Microsoft Copilot e VS Code.

> **Figure.** Parsing forty pages versus one typed MCP tool call.

Para quem decide sem ser desenvolvedor, a distinção que importa é esta. Quando um assistente lê o seu site, ele está *interpretando um documento*: pode ler mal uma tabela, perder uma nota de rodapé ou misturar duas variantes. Quando um assistente chama o seu servidor MCP, ele está *consultando um sistema*: pede a peça, recebe os campos e os informa. O primeiro modo produz respostas plausíveis. O segundo produz respostas corretas — desde que os dados por trás dele estejam corretos, que é onde está a maior parte do trabalho de verdade.

## Quem já lançou um neste setor?

Isso já não é especulativo, e os exemplos são variados de um jeito útil:

- **Microchip Technology** lançou um servidor MCP público e gratuito em 6 de novembro de 2025, expondo especificações de produto verificadas, datasheets, inventário, preços e prazos de entrega sobre MCP Streamable HTTP, com respostas codificadas em JSON voltadas a copilotos, chatbots e agentes corporativos.
- **Siemens** opera um servidor público em `mcp.siemens.com` cujos plugins documentados — ativos, portal do desenvolvedor, busca e conteúdo web — estão disponíveis sem autenticação.
- **Zoovu** lançou um servidor MCP em 11 de dezembro de 2025, dando aos agentes acesso governado aos dados de produto, posicionado em torno da exatidão em perguntas de compatibilidade e de aplicação.
- **ECIA** lançou o Inventory AI Agent Service da TrustedParts.com em 11 de junho de 2026, disponibilizando o inventário autorizado de componentes eletrônicos dentro do Microsoft Copilot, do ChatGPT e do Claude.
- **Shopify** expõe um servidor Storefront MCP nas lojas em `https://{shop}.myshopify.com/api/mcp`, com ferramentas como `search_catalog`, `lookup_catalog` e `get_product`, e sem autenticação exigida no nível storefront.

Dois padrões merecem atenção. Cada um deles se apoia sobre um repositório de dados autoritativo já existente. E cada um deles traça uma linha entre os dados públicos do catálogo e tudo o que é comercialmente sensível.

## Ferramentas ou recursos — o que um servidor de peças deve usar?

A especificação é explícita quanto à diferença, e errar nisso produz um servidor que os modelos usam mal.

**As ferramentas são controladas pelo modelo.** A especificação afirma que as ferramentas "são projetadas para ser **controladas pelo modelo**, o que significa que o modelo de linguagem pode descobrir e invocar ferramentas automaticamente com base em sua compreensão contextual e nos prompts do usuário". A descoberta é `tools/list`; a invocação é `tools/call`. Cada ferramenta carrega um `inputSchema` (JSON Schema 2020-12 por padrão), um `outputSchema` opcional, e devolve `structuredContent` em conformidade com esse esquema.

**Os recursos são orientados pela aplicação.** A especificação afirma que os recursos "são projetados para ser **orientados pela aplicação**, com as aplicações hospedeiras determinando como incorporar contexto conforme suas necessidades" — normalmente um seletor, uma lista ou a inclusão automática pelo host. Cada recurso é identificado por um URI, e os templates permitem URIs parametrizados.

Um catálogo é um espaço de consulta, não um conjunto fixo de documentos. Ninguém quer rolar um seletor de recursos com 40.000 peças. Por isso, a maior parte de um servidor de peças deve ser composta de ferramentas, com dois refinamentos: use blocos de conteúdo `resource_link` para apontar para datasheets e arquivos CAD em vez de embutir payloads grandes, e reserve recursos de verdade para um punhado de documentos estáveis, como um dicionário de classificação ou um log de alterações.

Dois detalhes da especificação atual compensam a atenção. As listas de ferramentas **não devem** variar por conexão, mas **podem** variar conforme a autorização apresentada na requisição. E os servidores **deveriam** devolver as ferramentas em uma ordem determinística, porque a ordenação estável permite que os clientes façam cache da lista e melhora a taxa de acerto do cache de prompt.

## O que mudou na especificação 2026-07-28?

Esta revisão remodelou o transporte, e qualquer projeto escrito com base em material de 2025 estará errado em pontos específicos.

| Mudança | Antes | A partir de 2026-07-28 |
| --- | --- | --- |
| Sessões | Cabeçalho `Mcp-Session-Id`, atribuído pelo servidor | Removidas; o estado passa como handles explícitos emitidos pelo servidor nos argumentos das ferramentas |
| Handshake | `initialize` / `notifications/initialized` | Removido; a versão do protocolo e as capacidades do cliente viajam em `_meta` em toda requisição |
| Descoberta de capacidades | Conhecida na inicialização | Novo RPC `server/discover` que os servidores **devem** implementar |
| Requisições iniciadas pelo servidor | Enviadas por um stream SSE | Requisições de múltiplas idas e voltas: o servidor devolve `resultType: "input_required"` e o cliente repete a chamada com `inputResponses` |
| Roteamento | Os gateways analisavam o corpo JSON | Cabeçalhos `Mcp-Method` e `Mcp-Name` **obrigatórios** nos POSTs |
| Cache | Apenas notificações `listChanged` | `ttlMs` e `cacheScope` obrigatórios nos resultados de listagem e de leitura |
| Retomada de stream | Repetição via `Last-Event-ID` | Removida; um stream interrompido perde a requisição e o cliente a reemite |

O formato do transporte agora é agradavelmente sem graça. O servidor expõe um único endpoint MCP que aceita POST — por exemplo, `https://example.com/mcp`. Cada requisição JSON-RPC é um POST próprio. Os clientes precisam enviar um cabeçalho `Accept` listando tanto `application/json` quanto `text/event-stream`, além de um cabeçalho `MCP-Protocol-Version` que precisa coincidir com o valor de `_meta` no corpo — caso contrário, o servidor precisa rejeitar com 400 e um erro `HeaderMismatch`. Os servidores precisam validar o cabeçalho `Origin` e responder 403 se ele estiver presente e for inválido.

A consequência prática para as equipes de infraestrutura: como não há sessão em nível de protocolo, o seu servidor MCP é implantado atrás de um balanceador de carga round-robin simples, como qualquer outro serviço HTTP stateless. Roots, Sampling e Logging agora estão descontinuados, com uma janela mínima de doze meses, e o antigo transporte HTTP+SSE também foi formalmente descontinuado.

## Como restringir preço e estoque com OAuth?

A autorização é **opcional** no MCP, o que é exatamente o certo para um servidor de peças: o catálogo público não deveria exigir token nenhum, e somente as ferramentas comercialmente sensíveis deveriam desafiar o chamador.

Quando você a implementa, os requisitos são específicos. O servidor MCP atua como um resource server OAuth 2.1, seguindo o draft OAuth 2.1 do IETF. Ele **deve** implementar o Protected Resource Metadata (RFC 9728), e os clientes **devem** usar esses metadados para descobrir o servidor de autorização. Os clientes **devem** implementar os Resource Indicators (RFC 8707), enviando um parâmetro `resource` que identifica o URI canônico do seu servidor tanto nas requisições de autorização quanto nas de token, e o seu servidor **deve** validar que os tokens foram emitidos para ele como público-alvo pretendido. Os servidores de autorização **deveriam** devolver o parâmetro `iss` conforme a RFC 9207, e os clientes precisam validá-lo. O Dynamic Client Registration agora está descontinuado em favor dos Client ID Metadata Documents, embora continue disponível por compatibilidade retroativa.

O padrão que funciona para um distribuidor ou fabricante:

1. **Nível não autenticado** — especificações, busca paramétrica, alternativas, documentos de conformidade, links de CAD e preços de tabela onde você os publica.
2. **Nível autenticado** — preços de contrato, disponibilidade específica por cliente, criação de cotação. Desafie com um 403 e `error="insufficient_scope"`, nomeando os escopos necessários para que o cliente consiga elevar o acesso em uma única ida e volta, em vez de várias.
3. **Nunca** use um identificador de cliente em um argumento de ferramenta como único controle de acesso. Um handle é um nome, não uma permissão; valide a autorização em toda chamada.

## O que um servidor MCP de peças deve expor?

De seis a oito ferramentas é a ordem de grandeza correta. Acima disso, a seleção feita pelo modelo se degrada.

| Ferramenta | Finalidade | Autorização |
| --- | --- | --- |
| `search_parts` | Busca paramétrica dentro de uma classe, com restrições tipadas e unidades | Pública |
| `get_part` | Registro canônico completo de um número de peça, incluindo procedência e data da última verificação | Pública |
| `find_alternates` | Equivalentes funcionais, segundas fontes e referências cruzadas de concorrentes, com uma base de equivalência declarada | Pública |
| `get_compliance_documents` | RoHS, REACH, declarações de desempenho, certificados, EPDs — como registros com datas de emissão, não apenas links | Pública |
| `get_cad_models` | Links de recurso para ativos 2D, 3D e BIM por formato | Pública |
| `get_availability` | Estoque em tempo real por localidade e prazo de entrega | Restrita |
| `get_price` | Preço de contrato do cliente por quantidade | Restrita |

A definição de uma ferramenta deve parecer banal, e é justamente esse o ponto:

```json
{
  "name": "search_parts",
  "title": "Parametric part search",
  "description": "Search the catalog by product class and typed parameter constraints. Returns matching parts with their key parametrics, units and last-verified date. Use get_part for the full record.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "product_class": { "type": "string", "description": "ETIM class code or class name" },
      "constraints": {
        "type": "array",
        "items": {
          "type": "object",
          "properties": {
            "parameter": { "type": "string" },
            "operator": { "type": "string", "enum": ["eq", "gte", "lte", "between", "in"] },
            "value": {},
            "unit": { "type": "string" }
          },
          "required": ["parameter", "operator", "value"]
        }
      },
      "limit": { "type": "integer", "default": 20 }
    },
    "required": ["product_class"],
    "additionalProperties": false
  }
}
```

Repare no que a descrição faz: ela diz ao modelo o que a ferramenta devolve *e* quando recorrer a uma ferramenta diferente. Esse único hábito faz mais pela qualidade das respostas do que qualquer quantidade de polimento de esquema.

## Um exemplo prático

Um engenheiro de projeto de um fabricante por contrato no Texas está substituindo uma peça em fim de vida em uma placa que também é enviada a um montador de painéis alemão. O assistente está com o servidor MCP do fabricante conectado.

> **Engenheiro:** O MOSFET de canal N de 60 V do nosso estágio buck está entrando em fim de vida. Preciso de um substituto direto no mesmo encapsulamento, com R_DS(on) não pior que 12 miliohms sob acionamento de porta de 10 V, e preciso saber se ele está realmente disponível.

O assistente faz quatro chamadas.

```text
→ tools/call  get_part
   { "part_number": "XYZ-60N12-D2PAK" }
← structuredContent
   { "package": "D2PAK", "vds_v": 60, "rds_on_mohm": 11.5,
     "vgs_meas_v": 10, "lifecycle": "EOL", "last_verified": "2026-08-04" }

→ tools/call  find_alternates
   { "part_number": "XYZ-60N12-D2PAK", "basis": "form_fit_function" }
← structuredContent
   [ { "part_number": "XYZ-60N10-D2PAK", "equivalence": "drop-in",
       "rds_on_mohm": 9.8, "differences": ["lower R_DS(on)", "higher Qg"] },
     { "part_number": "XYZ-60N14-D2PAK", "equivalence": "footprint",
       "rds_on_mohm": 13.5, "differences": ["exceeds R_DS(on) limit"] } ]

→ tools/call  get_availability
   { "part_numbers": ["XYZ-60N10-D2PAK"] }
← 403 Forbidden
   WWW-Authenticate: Bearer error="insufficient_scope",
     scope="stock:read", resource_metadata="https://mcp.example.com/.well-known/oauth-protected-resource"

   [client performs step-up authorisation, then retries]

← structuredContent
   { "part_number": "XYZ-60N10-D2PAK",
     "stock": [ { "location": "US-TX", "qty": 14200 },
                { "location": "DE-BW", "qty": 3800 } ],
     "lead_time_weeks": 8, "as_of": "2026-08-09T06:12:00Z" }

→ tools/call  get_compliance_documents
   { "part_number": "XYZ-60N10-D2PAK", "types": ["rohs", "reach"] }
← content: [ { "type": "resource_link", "uri": "https://…/rohs-2026-03.pdf",
               "name": "RoHS declaration (issued 2026-03-11)" } ]
```

O assistente então responde: um candidato é um substituto direto, com resistência de condução melhor e carga de porta maior, o que vale conferir contra o driver de porta; o segundo atende ao footprint, mas não cumpre o limite de R_DS(on); o estoque é de 14.200 no Texas e 3.800 em Baden-Württemberg na manhã de hoje, com prazo de entrega de oito semanas; as declarações de RoHS e REACH vêm anexadas com suas datas de emissão.

Nada aqui é impressionante como engenharia. É impressionante como *comércio*. Três decisões de sourcing foram tomadas sem que nenhuma pessoa abrisse um navegador, e cada número é rastreável até um registro com carimbo de data/hora.

## Quem consegue de fato alcançar o seu servidor hoje?

Seja honesto com a sua diretoria sobre isso, porque a resposta é mais estreita do que a maior parte do material dos fornecedores sugere.

| Cliente | Consegue alcançar um servidor MCP próprio? | Condições |
| --- | --- | --- |
| Claude | Sim | Conectores remotos personalizados nos planos Free, Pro, Max, Team e Enterprise; usuários gratuitos limitados a um; o servidor precisa estar acessível pela internet pública a partir das faixas de IP da Anthropic |
| ChatGPT | Em parte | Servidores MCP próprios via modo desenvolvedor; conectores com capacidade de escrita limitados a Business, Enterprise e Edu, com Plus e Pro somente leitura. Os apps no ChatGPT são construídos sobre MCP e passam por revisão de diretório |
| Gemini | Somente empresarial | Servidores MCP próprios registrados por um administrador como data store no Gemini Enterprise; apenas transporte Streamable HTTP |
| Microsoft Copilot | Sim, em configurações corporativas | Conectores registrados pelo administrador |
| Agentes de IDE e de CLI | Sim | O desenvolvedor configura o endpoint diretamente — o caminho de menor atrito para públicos de engenharia |
| Os agentes dos seus próprios clientes | Sim | Equipes de compras e de engenharia operam cada vez mais agentes internos; na prática, este é o chamador que mais cresce |

Ou seja, o MCP alcança engenheiros com um assistente que eles mesmos configuram e compradores corporativos cuja área de TI registra o seu servidor. É uma população pequena para os padrões da web e muito grande para os padrões de um funil comercial.

## Como os agentes descobrem o seu servidor?

Não existe descoberta em nível de DNS. Existem três mecanismos:

1. **O registro oficial de MCP** em `registry.modelcontextprotocol.io`, o repositório centralizado de metadados dos servidores publicamente acessíveis, apoiado por Anthropic, GitHub, Microsoft e PulseMCP. É de código aberto, suporta sub-registros e segue em preview antes da disponibilidade geral — portanto, espere mudanças.
2. **Diretórios do lado do cliente**, como o diretório de conectores do Claude e o diretório de aplicativos do ChatGPT, cada um com seu próprio processo de revisão.
3. **A sua própria documentação.** Hoje é assim que a maioria das conexões de fato acontece: uma página para desenvolvedores informa a URL do endpoint, a lista de ferramentas e os escopos de autorização, e um cliente a cola no assistente dele.

Publique o seu documento `.well-known/oauth-protected-resource` mesmo que a maioria das ferramentas seja pública, e versione o caminho do endpoint. Você vai mudar a sua superfície de ferramentas, e é melhor que isso seja uma migração deliberada, e não uma quebra silenciosa.

## Um checklist de implementação

1. **Consolide tudo em um registro canônico por peça**, com atributos tipados, unidades, procedência e carimbo de data/hora da última verificação. Não comece pelo protocolo.
2. **Escolha de seis a oito ferramentas** e escreva descrições que digam quando *não* usar cada uma.
3. **Declare esquemas de saída** e devolva `structuredContent`. Inclua unidades e datas de verificação em todo payload.
4. **Sirva um único endpoint POST**, honrando os cabeçalhos `Mcp-Method` e `Mcp-Name`, validando `Origin` e definindo `ttlMs` e `cacheScope` nos resultados de listagem.
5. **Separe as ferramentas públicas das restritas**, implemente os metadados da RFC 9728, valide o público-alvo do token conforme a RFC 8707 e use desafios de escopo para elevar o acesso em uma única ida e volta.
6. **Devolva uma ordenação determinística das ferramentas** e nomes de ferramentas estáveis, para que os caches dos clientes funcionem.
7. **Registre cada chamada** — ferramenta, argumentos, latência e se a consulta foi resolvida. Um servidor MCP sem analytics é um canal que você não consegue gerenciar.
8. **Monitore a exatidão contra a fonte de verdade**, continuamente. Uma ferramenta que devolve com confiança um valor nominal desatualizado é pior do que nenhuma ferramenta.

A Partsgraph fornece isso como uma camada gerenciada: consolidamos o seu catálogo existente em um único Parts Graph verificado, hospedamos o endpoint MCP com OAuth nos níveis restritos e informamos quais agentes chamaram o quê e onde as respostas estavam erradas.

Se você quer saber em que pé está antes de escrever qualquer linha de código, passe o seu domínio pelo avaliador gratuito em [/audit](/audit) — ele verifica o que as máquinas conseguem alcançar hoje no seu catálogo e se um endpoint MCP teria algo confiável para servir.

## Perguntas frequentes

### Precisamos de MCP se já temos uma API REST?

A sua API REST é a base correta, mas um agente não consegue usá-la sem um trabalho de integração sob medida feito por quem opera o agente. O MCP padroniza três coisas que uma API REST deixa em aberto: como um cliente descobre quais operações existem, como as entradas e saídas são tipadas para um modelo e como a autorização é negociada. Na prática, um servidor MCP de peças é uma projeção fina e opinativa de uma API existente, com esquemas e descrições escritos para um modelo, e não para um desenvolvedor.

### Os dados de peças devem ser expostos como ferramentas ou como recursos?

Na maior parte, como ferramentas. A especificação descreve as ferramentas como controladas pelo modelo — o modelo as descobre e as invoca a partir do contexto —, enquanto os recursos são orientados pela aplicação, apresentados pela aplicação hospedeira para o usuário selecionar. Um catálogo é um espaço de consulta, não uma lista fixa de arquivos, então o encaixe natural são ferramentas que recebem parâmetros. Os recursos justificam seu lugar em um pequeno número de documentos estáveis, e as ferramentas podem devolver links de recurso para datasheets e arquivos CAD em vez de embutir megabytes na resposta.

### A especificação 2026-07-28 quebra os servidores MCP existentes?

Ela muda bastante o formato do transporte. As sessões em nível de protocolo e o cabeçalho Mcp-Session-Id desapareceram, o handshake initialize desapareceu, o stream GET autônomo desapareceu e a retomada de SSE via Last-Event-ID desapareceu. Os servidores precisam implementar server/discover e exigir os cabeçalhos Mcp-Method e Mcp-Name nos POSTs. Os clientes que suportam as duas eras detectam qual delas um servidor fala tentando primeiro uma requisição moderna e inspecionando o corpo do erro antes de recuar para a versão antiga.

### Como impedimos que um agente veja o preço de outro cliente?

Use a camada de autorização, e não a obscuridade. O servidor MCP atua como um resource server OAuth 2.1, precisa implementar o Protected Resource Metadata (RFC 9728) e precisa validar que os tokens de acesso foram emitidos especificamente para ele como público-alvo pretendido, conforme a RFC 8707. Fundamental: a especificação permite que os conjuntos visíveis de ferramentas e recursos variem conforme a autorização apresentada na requisição, de modo que a um chamador não autenticado é possível mostrar apenas as ferramentas do catálogo público.

### Para começar, como um agente encontra o nosso servidor MCP?

Não existe mecanismo de descoberta em nível de DNS, e fingir o contrário é o erro mais comum nos textos sobre MCP. A descoberta acontece pelo registro oficial de MCP em registry.modelcontextprotocol.io, que tem o apoio de Anthropic, GitHub, Microsoft e PulseMCP e segue em preview antes da disponibilidade geral; por diretórios do lado do cliente, como o diretório de conectores do Claude e o diretório de aplicativos do ChatGPT; e, o mais comum hoje, porque você publicou a URL na sua documentação para desenvolvedores e um cliente a colou no assistente dele.

### Qual é o maior erro de projeto em um primeiro servidor MCP de peças?

Expor ferramentas demais com descrições vagas. Um modelo escolhe ferramentas a partir de seus nomes, descrições e esquemas, então vinte endpoints de busca sobrepostos produzem um comportamento pior do que seis bem nomeados. Devolva conteúdo estruturado conforme um esquema de saída declarado, mantenha os nomes das ferramentas determinísticos e estáveis e coloque unidades, tolerâncias e um carimbo de data/hora da última verificação no payload, para que a resposta possa ser auditada depois.

### Um servidor MCP ajuda na visibilidade em IA na web aberta?

Não diretamente. Os rastreadores de busca e de recuperação não chamam servidores MCP; eles baixam HTML. O MCP alcança usuários que conectaram o seu servidor, o que hoje significa engenheiros configurando um conector e compradores corporativos cujo administrador o registra. É um canal de profundidade, não de alcance, e funciona melhor ao lado de páginas de produto estruturadas e renderizadas no servidor.

## Fontes

1. [Anthropic, Introducing the Model Context Protocol (25 November 2024)](https://www.anthropic.com/news/model-context-protocol)
2. [Model Context Protocol, MCP joins the Agentic AI Foundation (9 December 2025)](https://blog.modelcontextprotocol.io/posts/2025-12-09-mcp-joins-agentic-ai-foundation/)
3. [Linux Foundation, Formation of the Agentic AI Foundation (9 December 2025)](https://www.linuxfoundation.org/press/linux-foundation-announces-the-formation-of-the-agentic-ai-foundation)
4. [Model Context Protocol, 2026-07-28 specification changelog](https://modelcontextprotocol.io/specification/2026-07-28/changelog)
5. [Model Context Protocol, Streamable HTTP transport (2026-07-28)](https://modelcontextprotocol.io/specification/2026-07-28/basic/transports/streamable-http)
6. [Model Context Protocol, Authorization (2026-07-28)](https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization)
7. [Model Context Protocol, Tools (2026-07-28)](https://modelcontextprotocol.io/specification/2026-07-28/server/tools)
8. [Model Context Protocol, Resources (2026-07-28)](https://modelcontextprotocol.io/specification/2026-07-28/server/resources)
9. [Model Context Protocol, The MCP Registry](https://modelcontextprotocol.io/registry/about)
10. [Microchip Technology, Microchip unveils Model Context Protocol (MCP) Server (6 November 2025)](https://ir.microchip.com/news-events/press-releases/detail/1344/microchip-technology-unveils-model-context-protocol-mcp-server-to-power-ai-driven-product-data-access)
11. [Siemens MCP Server documentation](https://mcp.siemens.com/docs)
12. [Zoovu, Zoovu launches MCP Server (11 December 2025)](https://zoovu.com/news/zoovu-launches-mcp-server)
13. [ECIA, TrustedParts.com launches Inventory AI Agent Service (11 June 2026)](https://www.ecianow.org/2026/06/11/trustedparts-com-launches-inventory-ai-agent-service/)
14. [Shopify, Storefront MCP server documentation](https://shopify.dev/docs/apps/build/storefront-mcp/servers/storefront)
15. [Anthropic, Get started with custom connectors using remote MCP](https://support.claude.com/en/articles/11175166-get-started-with-custom-connectors-using-remote-mcp)
16. [OpenAI Help Center, Developer mode and MCP apps in ChatGPT](https://help.openai.com/en/articles/12584461-developer-mode-and-mcp-apps-in-chatgpt)
17. [Google Cloud, Set up your custom MCP server data store (Gemini Enterprise)](https://docs.cloud.google.com/gemini/enterprise/docs/connectors/custom-mcp-server/set-up-custom-mcp-server)

## Other languages

- English: https://partsgraph.ai/blog/mcp-for-manufacturers/md
- Deutsch: https://partsgraph.ai/de/blog/mcp-for-manufacturers/md
- Français: https://partsgraph.ai/fr/blog/mcp-for-manufacturers/md
- Español: https://partsgraph.ai/es/blog/mcp-for-manufacturers/md
- Italiano: https://partsgraph.ai/it/blog/mcp-for-manufacturers/md
- Nederlands: https://partsgraph.ai/nl/blog/mcp-for-manufacturers/md
- Polski: https://partsgraph.ai/pl/blog/mcp-for-manufacturers/md
- Svenska: https://partsgraph.ai/sv/blog/mcp-for-manufacturers/md
- Türkçe: https://partsgraph.ai/tr/blog/mcp-for-manufacturers/md
- 日本語: https://partsgraph.ai/ja/blog/mcp-for-manufacturers/md
- 한국어: https://partsgraph.ai/ko/blog/mcp-for-manufacturers/md
- 简体中文: https://partsgraph.ai/zh/blog/mcp-for-manufacturers/md

---

Partsgraph — the agent-ready parts data layer. Free AI-visibility grader: https://partsgraph.ai/pt/audit