# MCP voor fabrikanten: een praktische gids

> Wat het Model Context Protocol is, wat een onderdelen-MCP-server moet bieden, hoe OAuth prijs en voorraad afschermt en welke assistenten er echt bij kunnen.

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

## In het kort

**Wat is MCP, en wat moet de MCP-server van een fabrikant aanbieden?**

MCP (het Model Context Protocol) is een open standaard waarmee een AI-assistent uw systemen rechtstreeks aanroept in plaats van antwoorden af te leiden uit uw webpagina's. De MCP-server van een fabrikant is een gehost HTTP-endpoint dat een kleine set getypeerde tools aanbiedt — parametrisch zoeken, artikelnummers opzoeken, alternatieven en cross-references, compliancedocumenten, CAD-links en met OAuth afgeschermde voorraad en prijzen — die elke compatibele assistent kan aanroepen voor een exact, controleerbaar antwoord. Onder de huidige specificatie 2026-07-28 is het een stateless request/response-service die achter een gewone load balancer draait. Het protocol is het makkelijke deel; het moeilijke deel is dat er één canoniek, geverifieerd productrecord achter zit.

---

## Wat is MCP, in gewone taal?

Het Model Context Protocol is een standaardmanier waarop een AI-assistent het systeem van iemand anders aanroept en een getypeerd, gestructureerd antwoord terugkrijgt.

Anthropic bracht het op 25 november 2024 als open source uit en omschreef het als “een nieuwe standaard om AI-assistenten te verbinden met de systemen waar data leeft”. Op 9 december 2025 schonk Anthropic MCP aan de Agentic AI Foundation, een geoormerkt fonds onder de Linux Foundation, mede opgericht met Block en OpenAI en op platinaniveau gesteund door AWS, Bloomberg, Cloudflare, Google en Microsoft. Op dat moment was MCP de 97 miljoen maandelijkse SDK-downloads gepasseerd en waren er meer dan 10.000 gepubliceerde servers, met eersteklas clientondersteuning in ChatGPT, Claude, Cursor, Gemini, Microsoft Copilot en VS Code.

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

Voor een beslisser zonder ontwikkelachtergrond is dit het verschil dat telt. Wanneer een assistent uw website leest, *interpreteert hij een document*: hij kan een tabel verkeerd lezen, een voetnoot missen of twee varianten door elkaar halen. Wanneer een assistent uw MCP-server aanroept, *bevraagt hij een systeem*: hij vraagt om het onderdeel, ontvangt de velden en rapporteert die. De eerste modus levert plausibele antwoorden op. De tweede levert juiste antwoorden op — mits de data erachter klopt, en daar zit het meeste echte werk.

## Wie heeft er in deze sector al een uitgebracht?

Dit is niet langer speculatief, en de voorbeelden zijn nuttig gevarieerd:

- **Microchip Technology** lanceerde op 6 november 2025 een gratis, publieke MCP-server die geverifieerde productspecificaties, datasheets, voorraad, prijzen en levertijden aanbiedt via MCP Streamable HTTP, met JSON-gecodeerde responses gericht op copilots, chatbots en enterprise agents.
- **Siemens** draait een publieke server op `mcp.siemens.com` waarvan de gedocumenteerde plug-ins — assets, developer portal, zoeken en webcontent — zonder authenticatie beschikbaar zijn.
- **Zoovu** lanceerde op 11 december 2025 een MCP-server die agents beheerste toegang tot productdata geeft, gepositioneerd rond nauwkeurigheid bij compatibiliteits- en toepassingsvragen.
- **ECIA** lanceerde op 11 juni 2026 de TrustedParts.com Inventory AI Agent Service, waarmee geautoriseerde voorraad van elektronische componenten beschikbaar komt binnen Microsoft Copilot, ChatGPT en Claude.
- **Shopify** biedt in winkels een Storefront MCP-server aan op `https://{shop}.myshopify.com/api/mcp`, met onder meer de tools `search_catalog`, `lookup_catalog` en `get_product`, waarbij voor de storefront-laag geen authenticatie nodig is.

Twee patronen zijn het opmerken waard. Elk van deze servers staat bovenop een bestaande, gezaghebbende dataopslag. En elk van hen trekt een grens tussen publieke catalogusdata en alles wat commercieel gevoelig is.

## Tools of resources — wat moet een onderdelenserver gebruiken?

De specificatie is expliciet over het verschil, en wie het verkeerd doet, bouwt een server die modellen slecht gebruiken.

**Tools zijn modelgestuurd.** De specificatie stelt dat tools “zijn ontworpen om **modelgestuurd** te zijn, wat betekent dat het taalmodel tools automatisch kan ontdekken en aanroepen op basis van zijn contextuele begrip en de prompts van de gebruiker”. Ontdekken gaat via `tools/list`, aanroepen via `tools/call`. Elke tool draagt een `inputSchema` (standaard JSON Schema 2020-12), optioneel een `outputSchema`, en geeft `structuredContent` terug dat aan dat schema voldoet.

**Resources zijn applicatiegestuurd.** De specificatie stelt dat resources “zijn ontworpen om **applicatiegestuurd** te zijn, waarbij hostapplicaties op basis van hun eigen behoeften bepalen hoe ze context opnemen” — doorgaans via een keuzelijst, een overzicht of automatische opname door de host. Elke resource wordt geïdentificeerd door een URI, en templates maken geparametriseerde URI's mogelijk.

Een catalogus is een zoekruimte, geen vaste documentenset. Niemand wil door een resource picker met 40.000 onderdelen scrollen. Het leeuwendeel van een onderdelenserver moet dus uit tools bestaan, met twee verfijningen: gebruik `resource_link`-contentblokken om naar datasheets en CAD-bestanden te verwijzen in plaats van grote payloads inline mee te sturen, en reserveer echte resources voor een handvol stabiele documenten, zoals een classificatiewoordenboek of een changelog.

Twee details uit de huidige specificatie verdienen aandacht. Toollijsten **mogen niet** per verbinding verschillen, maar **mogen** wel variëren met de autorisatie die bij de request wordt meegestuurd. En servers **zouden** tools in een deterministische volgorde moeten teruggeven, omdat een stabiele volgorde clients in staat stelt de lijst te cachen en de hitrate van de promptcache verbetert.

## Wat is er veranderd in de specificatie 2026-07-28?

Deze revisie heeft het transport hervormd, en elk ontwerp dat op materiaal uit 2025 is gebaseerd, zit op specifieke punten fout.

| Wijziging | Voorheen | Vanaf 2026-07-28 |
| --- | --- | --- |
| Sessies | Header `Mcp-Session-Id`, door de server toegekend | Verdwenen; state wordt doorgegeven als expliciete, door de server uitgegeven handles in toolargumenten |
| Handshake | `initialize` / `notifications/initialized` | Verdwenen; protocolversie en client-capabilities reizen bij elke request mee in `_meta` |
| Capability-discovery | Vastgesteld bij het initialiseren | Nieuwe `server/discover`-RPC die servers **moeten** implementeren |
| Door de server geïnitieerde requests | Verstuurd via een SSE-stream | Multi Round-Trip Requests: de server geeft `resultType: "input_required"` terug, de client probeert het opnieuw met `inputResponses` |
| Routing | Gateways parseerden de JSON-body | De headers `Mcp-Method` en `Mcp-Name` zijn **verplicht** bij POSTs |
| Caching | Alleen `listChanged`-notificaties | `ttlMs` en `cacheScope` verplicht bij list- en read-resultaten |
| Streamhervatting | Replay via `Last-Event-ID` | Verdwenen; een afgebroken stream verliest de request en de client verstuurt hem opnieuw |

De vorm van het transport is nu aangenaam saai. De server biedt één MCP-endpoint aan dat POST accepteert — bijvoorbeeld `https://example.com/mcp`. Elke JSON-RPC-request is een eigen POST. Clients moeten een `Accept`-header meesturen die zowel `application/json` als `text/event-stream` vermeldt, plus een `MCP-Protocol-Version`-header die overeen moet komen met de waarde in `_meta` in de body; anders moet de server weigeren met een 400 en een `HeaderMismatch`-fout. Servers moeten de `Origin`-header valideren en met 403 antwoorden als die aanwezig en ongeldig is.

Het praktische gevolg voor infrastructuurteams: omdat er geen sessie op protocolniveau bestaat, zet u uw MCP-server achter een gewone round-robin load balancer, net als elke andere stateless HTTP-service. Roots, Sampling en Logging zijn nu deprecated met een venster van minimaal twaalf maanden, en ook het oude HTTP+SSE-transport is formeel deprecated.

## Hoe schermt u prijs en voorraad af met OAuth?

Autorisatie is **optioneel** in MCP, en dat is precies goed voor een onderdelenserver: de publieke catalogus zou helemaal geen token nodig moeten hebben, en alleen commercieel gevoelige tools zouden om authenticatie moeten vragen.

Implementeert u het wel, dan zijn de eisen specifiek. De MCP-server fungeert als OAuth 2.1-resourceserver, conform de OAuth 2.1 IETF-draft. Hij **moet** Protected Resource Metadata (RFC 9728) implementeren, en clients **moeten** die metadata gebruiken om de autorisatieserver te ontdekken. Clients **moeten** Resource Indicators (RFC 8707) implementeren en in zowel autorisatie- als tokenrequests een `resource`-parameter meesturen die uw canonieke server-URI identificeert, en uw server **moet** valideren dat tokens voor hem als beoogde audience zijn uitgegeven. Autorisatieservers **zouden** de `iss`-parameter conform RFC 9207 moeten teruggeven, en clients moeten die valideren. Dynamic Client Registration is nu deprecated ten gunste van Client ID Metadata Documents, al blijft het beschikbaar voor achterwaartse compatibiliteit.

Het patroon dat werkt voor een distributeur of fabrikant:

1. **Niet-geauthenticeerde laag** — specificaties, parametrisch zoeken, alternatieven, compliancedocumenten, CAD-links en lijstprijzen waar u die publiceert.
2. **Geauthenticeerde laag** — contractprijzen, klantspecifieke beschikbaarheid, offertes aanmaken. Daag uit met een 403 en `error="insufficient_scope"`, met vermelding van de benodigde scopes, zodat de client in één round trip kan opschalen in plaats van in meerdere.
3. Zet **nooit** een klantidentificatie in een toolargument als enige toegangscontrole. Een handle is een naam, geen bevoegdheid; valideer de autorisatie bij elke aanroep.

## Wat moet een onderdelen-MCP-server aanbieden?

Zes tot acht tools is de juiste orde van grootte. Meer dan dat, en de toolkeuze van het model gaat achteruit.

| Tool | Doel | Auth |
| --- | --- | --- |
| `search_parts` | Parametrisch zoeken binnen een klasse met getypeerde constraints en eenheden | Publiek |
| `get_part` | Volledig canoniek record voor één artikelnummer, inclusief herkomst en datum van laatste verificatie | Publiek |
| `find_alternates` | Functionele equivalenten, tweede bronnen en cross-references van concurrenten, met een vermelde equivalentiegrondslag | Publiek |
| `get_compliance_documents` | RoHS, REACH, prestatieverklaringen, certificaten, EPD's — als records met uitgiftedatum, niet alleen als links | Publiek |
| `get_cad_models` | Resource links naar 2D-, 3D- en BIM-assets per formaat | Publiek |
| `get_availability` | Live voorraad per locatie en levertijd | Afgeschermd |
| `get_price` | Klantcontractprijzen bij een bepaalde afnamehoeveelheid | Afgeschermd |

Een tooldefinitie hoort er onopvallend uit te zien, en dat is precies de bedoeling:

```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
  }
}
```

Let op wat de beschrijving doet: ze vertelt het model wat de tool teruggeeft *én* wanneer het naar een andere tool moet grijpen. Die ene gewoonte doet meer voor de antwoordkwaliteit dan welke schemapoetserij dan ook.

## Een uitgewerkt voorbeeld

Een ontwerpengineer bij een contractfabrikant in Texas vervangt een end-of-life onderdeel in een print die ook naar een Duitse paneelbouwer gaat. De assistent heeft de MCP-server van de fabrikant gekoppeld.

> **Engineer:** De 60 V N-kanaals MOSFET in onze buck-trap gaat end-of-life. Ik heb een drop-in in dezelfde behuizing nodig, R_DS(on) niet slechter dan 12 milliohm bij 10 V gate-aansturing, en ik moet weten of hij daadwerkelijk leverbaar is.

De assistent doet vier aanroepen.

```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)" } ]
```

De assistent antwoordt vervolgens: één kandidaat is een drop-in met een lagere doorlaatweerstand en een hogere gate-lading, wat het waard is om tegen de gate driver te controleren; de tweede past op de footprint maar haalt de R_DS(on)-grens niet; de voorraad is vanochtend 14.200 in Texas en 3.800 in Baden-Württemberg, bij een levertijd van acht weken; RoHS- en REACH-verklaringen zijn bijgevoegd met hun uitgiftedatum.

Als techniek is hier niets indrukwekkends aan. Als *handel* wel. Er zijn drie inkoopbeslissingen genomen zonder dat een mens een browser opende, en elk cijfer is te herleiden tot een record met tijdstempel.

## Wie kan uw server vandaag daadwerkelijk bereiken?

Wees hier eerlijk over tegen uw directie, want het antwoord is smaller dan het meeste leveranciersmateriaal suggereert.

| Client | Bereikt hij een eigen MCP-server? | Voorwaarden |
| --- | --- | --- |
| Claude | Ja | Eigen remote connectors op Free, Pro, Max, Team en Enterprise; gratis gebruikers beperkt tot één; de server moet vanaf de IP-reeksen van Anthropic via het publieke internet bereikbaar zijn |
| ChatGPT | Gedeeltelijk | Eigen MCP-servers via de developer mode; schrijfbevoegde connectors beperkt tot Business, Enterprise en Edu, terwijl Plus en Pro alleen kunnen lezen. Apps in ChatGPT zijn op MCP gebouwd en doorlopen een directory-review |
| Gemini | Alleen Enterprise | Eigen MCP-servers die een beheerder in Gemini Enterprise als data store registreert; uitsluitend Streamable HTTP-transport |
| Microsoft Copilot | Ja, in enterprise-configuraties | Door de beheerder geregistreerde connectors |
| IDE- en CLI-agents | Ja | De ontwikkelaar configureert het endpoint rechtstreeks — de weg met de minste weerstand voor een technisch publiek |
| De eigen agents van uw klanten | Ja | Inkoop- en engineeringteams draaien steeds vaker interne agents; in de praktijk is dit de snelst groeiende aanroeper |

MCP bereikt dus engineers met een assistent die ze zelf configureren, en zakelijke inkopers wier IT-afdeling uw server registreert. Naar webmaatstaven is dat een kleine populatie, naar pipelinemaatstaven een zeer grote.

## Hoe ontdekken agents uw server?

Er is geen discovery op DNS-niveau. Er bestaan drie mechanismen:

1. **Het officiële MCP-register** op `registry.modelcontextprotocol.io`, de centrale metadata-repository voor publiek toegankelijke servers, gesteund door Anthropic, GitHub, Microsoft en PulseMCP. Het is open source, ondersteunt subregisters en is nog in preview in aanloop naar algemene beschikbaarheid — reken dus op verandering.
2. **Client-side directory's**, zoals de connectorsdirectory van Claude en de app-directory van ChatGPT, elk met een eigen reviewproces.
3. **Uw eigen documentatie.** Vandaag de dag komen de meeste koppelingen zo tot stand: een ontwikkelaarspagina vermeldt de endpoint-URL, de toollijst en de autorisatiescopes, en een klant plakt die in zijn client.

Publiceer uw `.well-known/oauth-protected-resource`-document, ook al zijn de meeste tools publiek, en versioneer het endpointpad. U gaat uw toolaanbod veranderen, en dat wilt u als een bewuste migratie doen, niet als een stille breuk.

## Een implementatiechecklist

1. **Herleid alles tot één canoniek record per onderdeel**, met getypeerde attributen, eenheden, herkomst en een last-verified-tijdstempel. Begin niet bij het protocol.
2. **Kies zes tot acht tools** en schrijf beschrijvingen die aangeven wanneer u ze juist *niet* moet gebruiken.
3. **Declareer outputschema's** en geef `structuredContent` terug. Neem in elke payload eenheden en verificatiedata op.
4. **Bied één POST-endpoint aan** waarin de headers `Mcp-Method` en `Mcp-Name` worden gehonoreerd, `Origin` wordt gevalideerd, en `ttlMs` en `cacheScope` op listresultaten zijn ingesteld.
5. **Scheid publieke en afgeschermde tools**, implementeer RFC 9728-metadata, valideer de token-audience conform RFC 8707 en gebruik scope-challenges om in één round trip op te schalen.
6. **Geef tools in een deterministische volgorde terug** met stabiele toolnamen, zodat clientcaches werken.
7. **Log elke aanroep** — tool, argumenten, latency en of de opzoeking iets opleverde. Een MCP-server zonder analytics is een kanaal dat u niet kunt sturen.
8. **Bewaak de nauwkeurigheid tegen de werkelijke brondata**, en doe dat continu. Een tool die stellig een verouderde waarde teruggeeft, is slechter dan geen tool.

Partsgraph levert dit als managed laag: wij herleiden uw bestaande catalogus tot één geverifieerde Parts Graph, hosten het MCP-endpoint met OAuth op de afgeschermde lagen, en rapporteren welke agents wat hebben aangeroepen en waar de antwoorden fout waren.

Wilt u weten waar u staat voordat u een regel code schrijft, laat uw domein dan door de gratis grader lopen op [/audit](/audit) — die controleert wat machines op dit moment in uw catalogus kunnen bereiken, en of een MCP-endpoint überhaupt iets betrouwbaars te serveren zou hebben.

## Veelgestelde vragen

### Hebben we MCP nodig als we al een REST API hebben?

Uw REST API is het juiste fundament, maar een agent kan die niet gebruiken zonder maatwerk-integratiewerk door degene die de agent beheert. MCP standaardiseert drie dingen die een REST API openlaat: hoe een client ontdekt welke operaties er zijn, hoe hun invoer en uitvoer voor een model zijn getypeerd, en hoe autorisatie wordt onderhandeld. In de praktijk is een onderdelen-MCP-server een dunne, uitgesproken projectie van een bestaande API, met schema's en beschrijvingen die voor een model zijn geschreven en niet voor een ontwikkelaar.

### Moeten onderdelendata als tools of als resources worden aangeboden?

Overwegend als tools. De specificatie omschrijft tools als modelgestuurd — het model ontdekt en roept ze aan vanuit de context — terwijl resources applicatiegestuurd zijn: de hostapplicatie toont ze zodat een gebruiker er een kiest. Een catalogus is een zoekruimte, geen vaste bestandenlijst, dus de natuurlijke keuze zijn tools die parameters aannemen. Resources verdienen hun plek voor een klein aantal stabiele documenten, en tools kunnen resource links naar datasheets en CAD-bestanden teruggeven in plaats van megabytes inline mee te sturen.

### Breekt de specificatie 2026-07-28 bestaande MCP-servers?

Ze verandert de vorm van het transport ingrijpend. Sessies op protocolniveau en de Mcp-Session-Id-header zijn verdwenen, de initialize-handshake is verdwenen, de losstaande GET-stream is verdwenen en SSE-hervatting via Last-Event-ID is verdwenen. Servers moeten server/discover implementeren en de headers Mcp-Method en Mcp-Name verplicht stellen op POSTs. Clients die beide tijdperken ondersteunen, bepalen welke een server spreekt door eerst een moderne request te proberen en de foutbody te inspecteren voordat ze terugvallen.

### Hoe voorkomen we dat een agent de prijzen van een andere klant ziet?

Gebruik de autorisatielaag en niet obscuriteit. De MCP-server fungeert als OAuth 2.1-resourceserver, moet Protected Resource Metadata (RFC 9728) implementeren en moet valideren dat access tokens specifiek voor hem als beoogde audience zijn uitgegeven, conform RFC 8707. Cruciaal is dat de specificatie toestaat dat de zichtbare sets tools en resources variëren met de autorisatie die bij de request wordt meegestuurd, zodat een niet-geauthenticeerde aanroeper alleen de publieke catalogustools te zien krijgt.

### Hoe vindt een agent onze MCP-server überhaupt?

Er bestaat geen discoverymechanisme op DNS-niveau, en doen alsof dat er wel is, is de meestgemaakte fout in publicaties over MCP. Ontdekking verloopt via het officiële MCP-register op registry.modelcontextprotocol.io, dat wordt gesteund door Anthropic, GitHub, Microsoft en PulseMCP en nog in preview is in aanloop naar algemene beschikbaarheid; via client-side directory's zoals de connectorsdirectory van Claude en de app-directory van ChatGPT; en, vandaag de dag het vaakst, doordat u de URL in uw ontwikkelaarsdocumentatie hebt gepubliceerd en een klant die heeft geplakt.

### Wat is de grootste ontwerpfout in een eerste onderdelen-MCP-server?

Te veel tools aanbieden met vage beschrijvingen. Een model kiest tools op basis van hun naam, beschrijving en schema, dus twintig overlappende zoek-endpoints leiden tot slechter gedrag dan zes goed benoemde. Geef gestructureerde content terug volgens een gedeclareerd outputschema, houd toolnamen deterministisch en stabiel, en zet eenheden, toleranties en een last-verified-tijdstempel in de payload, zodat het antwoord later controleerbaar is.

### Helpt een MCP-server bij AI-zichtbaarheid op het open web?

Niet direct. Crawlers voor zoeken en retrieval roepen geen MCP-servers aan; ze halen HTML op. MCP bereikt gebruikers die uw server hebben gekoppeld, en dat betekent vandaag engineers die een connector configureren en zakelijke inkopers wier beheerder hem registreert. Het is een diepgangkanaal, geen bereikkanaal, en het werkt het best naast server-rendered, gestructureerde productpagina's.

## Bronnen

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
- Polski: https://partsgraph.ai/pl/blog/mcp-for-manufacturers/md
- Português: https://partsgraph.ai/pt/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/nl/audit