<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[MCP-Server - Medium]]></title>
        <description><![CDATA[MCP Nexus: MCP Server News, Innovations, Strategies and Mastery - Medium]]></description>
        <link>https://medium.com/mcp-server?source=rss----3625a908dd02---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>MCP-Server - Medium</title>
            <link>https://medium.com/mcp-server?source=rss----3625a908dd02---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 03:00:10 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/mcp-server" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Meet Glxymesh: turn your ideas into hosted MCP tools]]></title>
            <link>https://medium.com/mcp-server/meet-glxymesh-turn-your-ideas-into-hosted-mcp-tools-3c693ae267cf?source=rss----3625a908dd02---4</link>
            <guid isPermaLink="false">https://medium.com/p/3c693ae267cf</guid>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[mcps]]></category>
            <category><![CDATA[llm-agent]]></category>
            <category><![CDATA[web-developer-tools]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Glxymesh]]></dc:creator>
            <pubDate>Thu, 15 Oct 2026 16:57:54 GMT</pubDate>
            <atom:updated>2026-10-15T16:57:52.982Z</atom:updated>
            <content:encoded><![CDATA[<p>In this post</p><ul><li>The launch video, in 90 seconds</li><li>From one sentence to a tested tool</li><li>What stays in your hands</li><li>One endpoint for every AI client</li></ul><p>AI models can reason, write and plan. Getting one to act, such as reading your GitHub issues or looking up a refund, still means building an MCP server, wiring APIs, storing secrets and keeping it all online. Glxymesh does that part, so you bring the idea and it becomes a hosted, connected MCP tool.</p><p>Meet Glxymesh, in 90 seconds. <a href="https://youtu.be/QZWW66tSpsU">Watch it on YouTube</a>.</p><h3>One tool, a whole infrastructure project</h3><p>The video opens on a simple request: “Get the latest issues from my GitHub repository.” To let an AI client do that on your own, you write an MCP server, put it behind HTTPS, add OAuth so clients can sign in, keep the GitHub token somewhere safe, and chase certificate errors and 401s when something drifts. The tool is a few lines. The plumbing around it is the project.</p><h3>Describe the tool you need</h3><p>In the console’s Builder, say what the tool should do and, if you like, link the API’s docs. Glxymesh reads the docs, plans the tool, writes it and checks it. Most tools are one request described in YAML and need no code at all.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vDv81RTA9la7B6KM" /></figure><p>Rather write it yourself? A tool is a tool.yml, plus one run function in Go, TypeScript or Python when it needs code. The <a href="https://www.glxymesh.com/blog/deploy-your-first-mcp-tool">MCP server tutorial</a> covers that path with the gxmesh CLI.</p><h3>You decide what it can reach</h3><p>The AI that writes a tool can’t give it network access or keys, and it can’t publish. Each draft lists the hosts its code calls and the keys it needs. You allow each host, add each key to the project’s vault, and the draft’s tests run on a preview with only what you allowed. When they pass, you publish.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*YfXog1yDfEsMCbAC" /></figure><p><strong>Keys never touch the code.</strong> The egress gateway adds each key to calls to its own host on the way out, so neither the tool nor the calling client holds it. <a href="https://www.glxymesh.com/blog/keeping-api-keys-out-of-your-tool-code">Keeping API keys out of your tool code</a> explains how.</p><h3>One project, one MCP endpoint</h3><p>Every project is one MCP server with one address. Claude, ChatGPT, Cursor, VS Code and other clients connect over Streamable HTTP and sign in with OAuth 2.1, so there is no API key to hand out. Every tool in the project is served from that one endpoint.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ijua_EduamFNB8FM" /></figure><p><a href="https://www.glxymesh.com/blog/connect-claude-chatgpt-and-gemini-to-one-endpoint">Connecting MCP servers to AI clients</a> walks through what happens the first time a client signs in.</p><h3>Built in from the first call</h3><p>Sign-in</p><p>Each client signs in to the project with OAuth 2.1</p><p>Network</p><p>A tool reaches only the hosts you allowed</p><p>Secrets</p><p>Encrypted in the project’s vault and added at egress</p><p>Traces</p><p>Every call recorded with its outcome and timing</p><p><a href="https://www.glxymesh.com/blog/how-a-request-moves-through-glxymesh">How a request moves through Glxymesh</a> follows one call through all of these, and <a href="https://www.glxymesh.com/blog/reading-your-invocation-history">reading your invocation history</a> shows what the traces tell you.</p><h3>Start building</h3><p>Spend less time managing infrastructure and more on what your AI can do next. Sign up at <a href="https://accounts.glxymesh.com/signup">accounts.glxymesh.com/signup</a>, and see the <a href="https://www.glxymesh.com/pricing">pricing page</a> for what the free plan includes.</p><p>Glxymesh team</p><p>Deploy a tool on the Free plan.</p><p>A month’s usage included. Calls stop when it is used up, so it never bills.</p><p><a href="https://platform.glxymesh.com/">Start building</a></p><p><em>Originally published at </em><a href="https://www.glxymesh.com/blog/meet-glxymesh"><em>https://www.glxymesh.com</em></a><em> on October 14, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3c693ae267cf" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mcp-server/meet-glxymesh-turn-your-ideas-into-hosted-mcp-tools-3c693ae267cf">Meet Glxymesh: turn your ideas into hosted MCP tools</a> was originally published in <a href="https://medium.com/mcp-server">MCP-Server</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[An MCP to sketch charts]]></title>
            <link>https://medium.com/mcp-server/an-mcp-to-sketch-charts-6d18342cee1b?source=rss----3625a908dd02---4</link>
            <guid isPermaLink="false">https://medium.com/p/6d18342cee1b</guid>
            <category><![CDATA[data-visualization]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[sketch]]></category>
            <dc:creator><![CDATA[Carmine De Stefano]]></dc:creator>
            <pubDate>Tue, 06 Oct 2026 10:35:32 GMT</pubDate>
            <atom:updated>2026-10-06T10:35:31.219Z</atom:updated>
            <content:encoded><![CDATA[<h4>A tour of its tools, demoed on a coffee guide</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AKCSPeQCIUVTE6orOkTVoQ.png" /><figcaption><em>Image generated by the author.</em></figcaption></figure><p>Most LLMs answer with a wall of text. On a good day you get a Mermaid diagram, and every Mermaid diagram looks like every other one: the same boxes, the same right angles, the same corporate blue. <a href="https://github.com/cadeos/scribbleviz-mcp">scribbleviz-mcp</a> hands the model a different pen. It’s six tools that turn structured input into sketch-style graphics, the wobbly notebook look you get from matplotlib’s plt.xkcd(). Everything is drawn procedurally, including the icons, and rendered straight to an in-memory PNG. Nothing is ever written to disk. The result comes back as a native MCP ImageContent the client can show inline.</p><p>Picking a diagram is really picking a decision. A line says “watch this trend”, a 2×2 says “these are your options”, a concept map says “this causes that”. When the model can reach for the right shape instead of defaulting to prose, its answers get easier to scan. The clearest way to show what the tools do is to make them explain something real, so I asked for the one thing every keyboard runs on: coffee. One field guide, one page per tool, all in the warm sepia palette so it reads like a single notebook rather than seven screenshots.</p><h3>How it works, in one paragraph</h3><p>It’s a small, single-file Python MCP server with two dependencies (mcp and matplotlib) and no database, no browser, no temp files. Point any MCP client at it (Claude Desktop, Cursor, Cline, Continue, Zed, Windsurf) and the tools show up automatically. Each one takes plain structured arguments such as labels and values, dated events, nodes and edges, or quadrant contents, picks a palette, and hands back a PNG. There&#39;s no templating language to learn and no headless Chrome to babysit; the whole thing is stateless. The JSON snippets below are the exact tool calls that produced each picture in this post, so you can paste any of them into an MCP client and get the same image back.</p><h3>1. The curve</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_whRV8GyUT6jYa3KoaccTQ.png" /><figcaption><em>A line chart: caffeine rising and fading over the hours after a cup.</em></figcaption></figure><p>Caffeine hits fast and leaves slowly. It’s almost fully absorbed within 45 minutes, peaks in the blood roughly 30 to 60 minutes after a cup, and then decays on a half-life of about five hours. That long tail explains a lot of bad nights: an innocent 4 p.m. espresso still has about a quarter of its punch in your system at 9 p.m. A line chart is a good fit here, because the eye reads the steep climb and the slow fade as one gesture in a way a table of numbers never manages.</p><p>The star marks the peak. Any data point can carry a marker, either through the parallel icons list (one entry per value, &quot;&quot; to skip) or with an inline [icon] token. The same twenty hand-drawn glyphs are available on every tool, so a star here is stroked with the same wobble as a star on the timeline three sections down.</p><pre>{<br>  &quot;chart_type&quot;: &quot;line&quot;,<br>  &quot;title&quot;: &quot;Caffeine in your bloodstream&quot;,<br>  &quot;labels&quot;: [&quot;0h&quot;, &quot;1h&quot;, &quot;2h&quot;, &quot;4h&quot;, &quot;6h&quot;, &quot;8h&quot;, &quot;10h&quot;, &quot;12h&quot;],<br>  &quot;values&quot;: [0, 95, 88, 68, 52, 39, 30, 22],<br>  &quot;x_label&quot;: &quot;hours after a cup&quot;,<br>  &quot;y_label&quot;: &quot;caffeine (mg)&quot;,<br>  &quot;palette&quot;: &quot;sepia&quot;,<br>  &quot;icons&quot;: [&quot;&quot;, &quot;star&quot;, &quot;&quot;, &quot;&quot;, &quot;&quot;, &quot;&quot;, &quot;&quot;, &quot;&quot;],<br>  &quot;background&quot;: &quot;white&quot;<br>}</pre><h3>2. The comparison</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Yn_9SG0vxvJzq65J99_eIg.png" /><figcaption><em>A bar chart: caffeine per typical serving, from decaf to cold brew.</em></figcaption></figure><p>Same tool, one different argument. Flip chart_type from line to bar and the caffeine story turns into a ranking instead of a trajectory: which drink actually hits hardest? A single shot of espresso (about 63 mg) carries less caffeine than a mug of drip coffee (about 95 mg), because drip uses far more water and contact time. Cold brew tops the chart by a wide margin, since long steeping extracts a lot, and decaf isn&#39;t zero, just close to it. Bars are the right shape when the question is &quot;which is biggest&quot;, where a line would imply a trend that isn&#39;t there.</p><p>The bars are sorted low to high so the eye lands on the winner, and the bolt icon flags it. This is the same icons mechanism as the line chart, which is the practical benefit of one tool covering four chart types: you learn the arguments once and they carry over.</p><pre>{<br>  &quot;chart_type&quot;: &quot;bar&quot;,<br>  &quot;title&quot;: &quot;Caffeine per serving&quot;,<br>  &quot;labels&quot;: [&quot;Decaf&quot;, &quot;Instant&quot;, &quot;Espresso&quot;, &quot;Latte&quot;, &quot;Drip&quot;, &quot;Cold brew&quot;],<br>  &quot;values&quot;: [3, 62, 63, 68, 95, 165],<br>  &quot;x_label&quot;: &quot;&quot;,<br>  &quot;y_label&quot;: &quot;caffeine (mg)&quot;,<br>  &quot;palette&quot;: &quot;sepia&quot;,<br>  &quot;icons&quot;: [&quot;&quot;, &quot;&quot;, &quot;&quot;, &quot;&quot;, &quot;&quot;, &quot;bolt&quot;],<br>  &quot;background&quot;: &quot;white&quot;<br>}</pre><h3>3. The history</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xh_waD_9nQ8lWMOr9Kr_Jw.png" /><figcaption><em>A timeline: six milestones from Kaldi’s goats to third-wave coffee.</em></figcaption></figure><p>Coffee’s story is a chain of happy accidents. The legend starts in 9th-century Ethiopia with Kaldi, a goatherd who noticed his flock wouldn’t sleep after nibbling certain berries. From there it travels. Sufi shrines in Yemen brewed <em>qahwa</em> to stay awake through night prayers, coffee houses reached Europe in the 1600s and became hubs of gossip and business, the first espresso machine arrived in 1884, and a little shop opened in Seattle in 1971. Each beat is a <em>when</em> and a <em>what</em>, exactly the two fields a timeline wants.</p><p>generate_timeline alternates milestones above and below a single spine so the labels never collide, and each event carries its own icon through an inline [token] dropped into the text ([leaf], [drop], [home], [gear], [flag], [star]). The tool sizes the canvas to the number of events and leaves headroom for those icons, so nothing crowds the edges however many beats you pass in.</p><pre>{<br>  &quot;title&quot;: &quot;A short history of coffee&quot;,<br>  &quot;events&quot;: [<br>    [&quot;9th c.&quot;, &quot;Kaldi &amp; the dancing goats [leaf]&quot;],<br>    [&quot;1450s&quot;, &quot;Sufi shrines brew qahwa [drop]&quot;],<br>    [&quot;1600s&quot;, &quot;Coffee houses reach Europe [home]&quot;],<br>    [&quot;1884&quot;, &quot;First espresso machine [gear]&quot;],<br>    [&quot;1971&quot;, &quot;A little shop in Seattle [flag]&quot;],<br>    [&quot;2000s&quot;, &quot;Third-wave craft coffee [star]&quot;]<br>  ],<br>  &quot;palette&quot;: &quot;sepia&quot;,<br>  &quot;background&quot;: &quot;white&quot;<br>}</pre><h3>4. The methods</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZQxyBRH8dd-xZg9x4aCOSw.png" /><figcaption><em>A mind map: six brewing methods branching off one hub.</em></figcaption></figure><p>There is no single “right” way to make coffee. There’s a whole radial family of them, and they trade the same three levers in different proportions: pressure, contact time, and filtration. Espresso is all pressure and almost no time; cold brew is all time and no heat; pour-over leans on a paper filter for a clean cup; the French press skips the filter entirely for a heavier, sediment-rich body. A mind map fits a set of siblings like this: one central idea in the middle, variations spraying out around it, none of them first.</p><p>generate_mind_map takes a central_topic and a list of branches, where each branch is a label plus a short note, and lays them out evenly around the hub with no positioning math on your side. Reach for it when the relationship is &quot;these all belong to that&quot;, as opposed to the ordered, this-then-that chain in the next section.</p><pre>{<br>  &quot;title&quot;: &quot;Ways to brew&quot;,<br>  &quot;central_topic&quot;: &quot;Brewing&quot;,<br>  &quot;branches&quot;: [<br>    [&quot;Espresso&quot;, &quot;9 bar; ~30 s; crema&quot;],<br>    [&quot;Pour-over&quot;, &quot;paper filter; clean cup&quot;],<br>    [&quot;French press&quot;, &quot;full immersion; bold&quot;],<br>    [&quot;Moka pot&quot;, &quot;stovetop; strong&quot;],<br>    [&quot;Cold brew&quot;, &quot;12-24 h; low acidity&quot;],<br>    [&quot;AeroPress&quot;, &quot;quick; forgiving&quot;]<br>  ],<br>  &quot;palette&quot;: &quot;sepia&quot;,<br>  &quot;background&quot;: &quot;white&quot;<br>}</pre><h3>5. Bean to cup</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XCwU8kV15LwqpQxGiLbVhw.png" /><figcaption><em>A concept map: the directed chain from cherry to cup.</em></figcaption></figure><p>The mind map showed siblings; a process is different, because it has direction. A coffee cherry is picked and milled into a green bean, roasted into the brown bean you recognize, ground, hit with hot water, and poured. Each step transforms the one before it, and you can’t reorder them. When the story is a chain like that, this becomes that which becomes the next, a concept map with directed edges says it best, because the arrows carry meaning a plain list can’t. Every arrow here is labelled with the <em>verb</em> that gets you from one node to the next.</p><p>generate_concept_map takes nodes and edges, where each edge is [from, to, label], plus a directed flag that turns the connectors into arrows. It&#39;s the most general of the six tools, since anything you could draw as a labelled graph fits, which also makes it the one to reach for last, once you&#39;ve ruled out the more specific shapes above.</p><pre>{<br>  &quot;title&quot;: &quot;From bean to cup&quot;,<br>  &quot;nodes&quot;: [&quot;Cherry&quot;, &quot;Green bean&quot;, &quot;Roasted bean&quot;, &quot;Grounds&quot;, &quot;Brew&quot;, &quot;Cup&quot;],<br>  &quot;edges&quot;: [<br>    [&quot;Cherry&quot;, &quot;Green bean&quot;, &quot;pick &amp; mill&quot;],<br>    [&quot;Green bean&quot;, &quot;Roasted bean&quot;, &quot;roast&quot;],<br>    [&quot;Roasted bean&quot;, &quot;Grounds&quot;, &quot;grind&quot;],<br>    [&quot;Grounds&quot;, &quot;Brew&quot;, &quot;hot water&quot;],<br>    [&quot;Brew&quot;, &quot;Cup&quot;, &quot;pour&quot;]<br>  ],<br>  &quot;directed&quot;: true,<br>  &quot;palette&quot;: &quot;sepia&quot;,<br>  &quot;background&quot;: &quot;white&quot;<br>}</pre><h3>6. The cheat-sheet</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ORIPYXhIiskfVxfhO5jOCw.png" /><figcaption><em>A sketch note: an espresso recipe as a sticky note.</em></figcaption></figure><p>Some knowledge just wants to be a sticky note on the wall. Not a trend, not a graph, just a handful of numbers you glance at while the machine warms up. The classic espresso recipe is exactly that: an 18 g dose in, about 36 g of liquid out (a 1:2 ratio), pulled in 25 to 30 seconds, with grind size as the dial you turn to hit that window. Too fast and it’s sour and thin; too slow and it’s bitter. That’s four labelled ideas with a couple of lines each, a cheat-sheet rather than a chart.</p><p>generate_sketch_note renders each section as its own labelled box, laid out in two columns and packed to fit, with an icon per heading (target, gear, clock, bulb). Use it for reference material like a recipe, a checklist, or a set of definitions, where the items don&#39;t connect to each other and you just want them legible at a glance.</p><pre>{<br>  &quot;title&quot;: &quot;How to pull a good shot&quot;,<br>  &quot;sections&quot;: [<br>    [&quot;Dose [target]&quot;, &quot;18 g in; 36 g out&quot;],<br>    [&quot;Grind [gear]&quot;, &quot;fine; adjust to taste&quot;],<br>    [&quot;Time [clock]&quot;, &quot;25-30 seconds&quot;],<br>    [&quot;Tips [bulb]&quot;, &quot;fresh beans; clean basket; even tamp&quot;]<br>  ],<br>  &quot;palette&quot;: &quot;sepia&quot;,<br>  &quot;background&quot;: &quot;white&quot;<br>}</pre><h3>7. Pick your brew</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iauSsEJdGscQ9i63Rz7hzw.png" /><figcaption><em>A 2×2 matrix: brewing methods sorted by contact time and body.</em></figcaption></figure><p>Two questions decide most cups: how much <em>time</em> you’re willing to give it, and how much <em>body</em> you want. Cross those as axes and the brewing methods sort themselves into four corners: quick-and-intense espresso in one, slow-and-heavy French press in another, fast-and-clean AeroPress for travel, delicate pour-over and cold brew for a nuanced cup. A 2×2 works as a small decision tool, because it doesn’t only list the options, it also shows why each one lands where it does.</p><p>generate_quadrant takes the two axis labels and the four quadrants (each a heading plus a few lines), and it&#39;s the same engine behind a SWOT, an Eisenhower matrix, or any &quot;compare on two dimensions&quot; prompt. Flags like headings_outside and icon_focus let it swing from a text-heavy analysis to an all-icon poster, but the core idea stays the same: position carries the argument.</p><pre>{<br>  &quot;title&quot;: &quot;Pick your brew&quot;,<br>  &quot;x_axis&quot;: &quot;contact time: quick -&gt; slow&quot;,<br>  &quot;y_axis&quot;: &quot;body: light -&gt; full&quot;,<br>  &quot;quadrants&quot;: [<br>    [&quot;Espresso&quot;, &quot;9 bar; ~30 s; intense&quot;],<br>    [&quot;French press / Moka&quot;, &quot;full immersion; heavy&quot;],<br>    [&quot;AeroPress&quot;, &quot;fast; clean; travel&quot;],<br>    [&quot;Pour-over / Cold brew&quot;, &quot;delicate; nuanced&quot;]<br>  ],<br>  &quot;palette&quot;: &quot;sepia&quot;,<br>  &quot;background&quot;: &quot;white&quot;<br>}</pre><h3>Why sketch-style?</h3><p>A crisp, precise chart says <em>dashboard</em>: this is final, audited, don’t touch. A wobbly one says <em>notebook</em>: here’s a rough idea, follow along, question it. That lower-stakes feeling is what you want when an assistant is explaining something rather than reporting it. It reads like thinking out loud, not like a finished report you’re expected to accept.</p><p>It also keeps things consistent. Because the icons are drawn with the same jittered stroke as the boxes, the lines and the arrows, nothing looks pasted in from a different app, and there’s no clip-art star sitting awkwardly on a clean vector chart. Seven pictures, one hand. And since it all renders through matplotlib to an in-memory buffer, there’s no browser to launch and no file to clean up. The model calls a tool and gets a picture back.</p><h3>Try it yourself</h3><pre>git clone https://github.com/cadeos/scribbleviz-mcp.git<br>cd scribbleviz-mcp<br>python -m venv .venv &amp;&amp; source .venv/bin/activate<br>pip install -r requirements.txt</pre><p>Then register it in your MCP client, using the same command and args shape everywhere. Point command at the venv&#39;s Python so mcp and matplotlib are on the path, and use absolute paths:</p><pre>{<br>  &quot;mcpServers&quot;: {<br>    &quot;scribbleviz&quot;: {<br>      &quot;command&quot;: &quot;/absolute/path/to/scribbleviz-mcp/.venv/bin/python&quot;,<br>      &quot;args&quot;: [&quot;/absolute/path/to/scribbleviz-mcp/server.py&quot;]<br>    }<br>  }<br>}</pre><p>Restart the client and the generate_* tools appear. Hand your model a brief such as &quot;explain X&quot; and let it reach for the right page.</p><h3>Contribute</h3><p>The project is open source and small enough to read in one sitting, which makes it easy to extend. If you have an idea, the repo welcomes pull requests. A few directions that would fit well: new color palettes, more hand-drawn icons, extra chart types, better auto-layout for dense diagrams, or examples in other languages. Bug reports and issues are just as useful, so open one if something renders wrong or a tool signature trips you up. Star the repo if it was handy, fork it, and send your changes back.</p><p>Repo: <a href="https://github.com/cadeos/scribbleviz-mcp">github.com/cadeos/scribbleviz-mcp</a> · MIT licensed</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6d18342cee1b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mcp-server/an-mcp-to-sketch-charts-6d18342cee1b">An MCP to sketch charts</a> was originally published in <a href="https://medium.com/mcp-server">MCP-Server</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[OAuth 2.1 for a Personal MCP Server: What Three Months in Production Changed]]></title>
            <link>https://medium.com/mcp-server/oauth-2-1-for-a-personal-mcp-server-what-three-months-in-production-changed-c082ee822a8b?source=rss----3625a908dd02---4</link>
            <guid isPermaLink="false">https://medium.com/p/c082ee822a8b</guid>
            <category><![CDATA[oauth]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[open-source]]></category>
            <dc:creator><![CDATA[aliasunder]]></dc:creator>
            <pubDate>Sat, 05 Sep 2026 06:19:36 GMT</pubDate>
            <atom:updated>2026-09-05T06:19:35.169Z</atom:updated>
            <content:encoded><![CDATA[<p><a href="https://github.com/aliasunder/vault-cortex">Vault Cortex</a> is an open-source MCP server that gives Claude read and write access to my Obsidian vault from any device. The vault is my entire second brain, and the server sits on the public internet so that claude.ai on my phone can reach it. That requirement rules out a static token on its own, because claude.ai’s connector model for an individual account offers OAuth or nothing.</p><p><a href="https://www.bluerock.io/use-cases/safely-adopt-mcp">One 2026 analysis</a> found that 41% of MCP servers ship with no authentication at all, and only 8.5% implement OAuth. This post covers the auth architecture of one server in the 8.5%: the threat model, each decision and the reasoning behind it, and what three months of production traffic changed.</p><h3>The Threat Model</h3><p>Vault Cortex is a single-user server. There’s no tenant isolation to get wrong and no lateral movement to contain. But behind that one credential is every note I’ve written: code opinions, travel itineraries, the session history of every project I work on. Community plugins also store third-party API keys in .obsidian/ config files, which is why dot-prefixed paths like that folder are blocked from every vault operation; a leaked token shouldn&#39;t hand over a second set of secrets on top of the notes. A breach exposes all of it at once, so the design treats one user&#39;s data as high-value.</p><p>The server also runs in two deployment shapes. My reference deployment is an Express server in a Docker container on an AWS Lightsail VPS. In front of it sits, in order, a Cloudflare-proxied custom domain, API Gateway with a Lambda authorizer, and a Cloudflare Tunnel to the container’s origin. Cloudflare’s WAF and DDoS protection sit on the public endpoint, the gateway’s default execute-api hostname is disabled so the proxied domain is the only way in, and Cloudflare Access restricts the tunnel to gateway traffic. The one-click Render and Railway deploys run with nothing in front: the container authenticates every request itself. Whatever the container does on its own has to be sufficient, and whatever the gateway adds is extra.</p><pre>Reference (AWS):  client → Cloudflare (proxied domain, WAF)<br>                         → API Gateway (Lambda authorizer)<br>                         → Cloudflare Tunnel (Access-locked)<br>                         → container (Express)<br>One-click:        client → container (Express)</pre><p>At this scale, the flow the MCP spec describes is enough, because the threats a single-user server faces are the ones OAuth 2.1 already handles: an access token that leaks stops working at its 6-hour expiry, a stranger who finds the endpoint can register a client but can’t get past the consent page without the static token, and rotating that one token revokes every JWT and refresh token at once. The part of OAuth it leaves out, scopes that partition privilege between users, is the part a one-user server has no use for. The production numbers <a href="#8efc">come later</a>, but the summary is that across every 30-day log window I’ve audited, nothing unauthenticated from the internet has reached the server itself. One user and nine registered clients (Claude apps and CLI tools across my devices) is not a stress test, so the zeros in this post show the auth stack running correctly unattended; they don’t show it surviving an adversary.</p><h3>Two Credentials, Two Kinds of Client</h3><p>OAuth was the plan from the start. A public server with write access to my notes needs tokens that expire and can be revoked, and a static key gives you neither. claude.ai’s connector model removed the alternative anyway: on an individual account there is no way to set up a manual connector with a static token. (A request-header credential <a href="https://claude.com/docs/connectors/custom/remote-mcp#authenticating-with-request-headers">exists in beta</a> for a limited set of organizations, entered once by an admin and shared by everyone in the org, which is the opposite of what a personal server needs.)</p><p>I kept a static bearer token alongside OAuth because the clients fall into two groups. Browser-capable clients (Claude Desktop, Claude Code, claude.ai) use OAuth 2.1 with Authorization Code + PKCE, which gives them tokens that expire and rotate and leaves no secret sitting in a config file after the initial consent. CLI tools, MCP Inspector, curl, and automation use the static token, because there’s no browser to complete a flow, and a value in a config file or an environment variable is what those tools expect. Browser clients still enter the static token once, at the consent page; after that they hold only their own tokens.</p><p>The static token never expires, while OAuth access tokens live 6 hours. Since it’s the key every JWT is signed with and the key the refresh-token rows are stored under, rotating the static token ends every session at once. The moment the new secret is live, every issued JWT fails its signature check and every stored refresh token becomes unreachable. Between rotations, an access token is revoked early only if its client revokes it or its refresh token is caught being reused, so a leaked JWT that nobody has noticed works until it expires. The access token lifetime is the only limit on that window, and the logs show that shortening it is nearly free. In 59 days of logs, none of the logged 75 silent refreshes across 9 clients produced a visible interruption, so I lowered the lifetime from 24 hours to 6. One hour would put a refresh inside almost every working session for limited benefit. Because the static token signs every JWT, the one credential that never expires is the one a leak would hurt most, and the <a href="#e716">refresh token section</a> explains why I kept it that way.</p><h3>What the MCP Spec Requires</h3><p>Authorization is optional in the <a href="https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization">MCP specification</a>, so a server with no authentication at all still conforms. When a server does authenticate over HTTP, the MCP spec’s answer is <a href="https://datatracker.ietf.org/doc/draft-ietf-oauth-v2-1/">OAuth 2.1</a> (still an IETF draft, in its fifteenth revision as I write this). Most walkthroughs of that flow are written by companies selling a hosted authorization server, so they describe the parts you hand off. This is what the flow looks like when your own server is the authorization server. Condensed from the auth section of the repo’s <a href="https://github.com/aliasunder/vault-cortex/blob/main/ARCHITECTURE.md#auth-oauth-21--defense-in-depth">ARCHITECTURE.md</a>, it’s nine steps:</p><pre>1. POST /mcp (no token)                        → 401, WWW-Authenticate points at discovery<br>2. GET /.well-known/oauth-protected-resource   → where the authorization server lives<br>   (also served at .../oauth-protected-resource/mcp, the RFC 9728 path-suffixed form)<br>3. GET /.well-known/oauth-authorization-server → the endpoint list<br>4. POST /register                              → dynamic client registration<br>5. GET /authorize?...&amp;code_challenge=...       → consent page in the browser<br>6. user approves with the static token         → redirect back with an authorization code<br>7. POST /token (code + code_verifier)          → JWT access token + refresh token<br>8. POST /mcp (Authorization: Bearer &lt;JWT&gt;)     → real requests<br>9. POST /token (refresh_token) on expiry       → new JWT, no browser</pre><p>Step 4 is dynamic client registration: you don’t pre-register Claude as a client. On first connect the client sends its own name and redirect URIs to /register and gets a client ID back. The July 2026 revision of the MCP spec deprecates dynamic registration, keeping it only for backwards compatibility, and recommends <a href="https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization/client-registration#client-id-metadata-documents">Client ID Metadata Documents</a> instead, where a client identifies itself by a URL it hosts. The SDK&#39;s server side doesn&#39;t support those documents yet, so this server still registers clients dynamically. For this server, the benefit would be at registration: a client identified by a URL it hosts needs no row written at registration, and that unauthenticated write is what the <a href="#f659">rate-limiting section</a> is about.</p><figure><img alt="The nine-step OAuth 2.1 flow between an MCP client and Vault Cortex" src="https://cdn-images-1.medium.com/max/1024/1*OAJ-sxu2g8vpf-ald34FcQ.png" /><figcaption><em>The flow at a glance. The only human step is the consent click.</em></figcaption></figure><p>/authorize is a public page, so the consent step is where the access control happens: the page requires the static bearer token, and approving means proving you already hold the server&#39;s secret. That&#39;s also what makes open dynamic client registration safe here. Anyone can register a client, but a registration that never passes consent never returns a token, and a registered redirect_uri has to match exactly at authorization time (the SDK relaxes only the port, for <a href="https://www.rfc-editor.org/rfc/rfc8252">RFC 8252</a> loopback clients), so a registration can&#39;t redirect a real user&#39;s authorization code elsewhere. The residual attack is social: anyone can register a client with a familiar name and their own redirect URI, and the consent page will display whatever name they picked. The limit is that approving takes the static token and there&#39;s only one server operator: the only consent page I should ever see is the one I just caused to open, so an authorize link arriving any other way is an obvious signal something is not quite right.</p><figure><img alt="The consent page with application name, client ID, requested scopes, a token field, and Deny and Approve buttons" src="https://cdn-images-1.medium.com/max/1024/1*vKl4CHmglW1YHKoaOevGLg.png" /><figcaption><em>The consent page. The token field is the gate: approving proves you hold the server’s secret.</em></figcaption></figure><p>One consequence follows from the MCP spec: the discovery endpoints have to be unauthenticated, because a client that can’t discover your auth server can’t authenticate, and that routing constraint comes back in <a href="#17fd">the section on API Gateway.</a> The TypeScript MCP SDK, for its part, ships the OAuth router, the requireBearerAuth middleware, and per-endpoint rate-limit defaults. The provider you plug into them is the part you write: token issuance and verification, the SQLite token store, refresh rotation, the consent page, and revocation.</p><p>In practice the flow is mostly invisible. Over 59 days of production logs ending August 22, I counted 8 consent flows in the browser; every other token issued in that window, about 90% of them, came from a silent refresh. The access token itself carries six claims: sub, scope, exp, iss, aud, and iat.</p><h3>Verifying Twice</h3><p>In the <a href="https://github.com/aliasunder/vault-cortex/blob/main/DEPLOY.md">reference deployment</a>, every /mcp request is validated twice independently. API Gateway&#39;s Lambda authorizer checks the Bearer token at the edge, then Express checks it again with the SDK&#39;s requireBearerAuth. Both verify the JWT against the same HMAC secret and share nothing else: no session store, no introspection endpoint, and no network hop between validators.</p><p>The two layers check different things on purpose. The Lambda is stateless: it validates the static token, or a JWT’s signature, expiry, issuer, and audience, and that’s all it can do without a database. The revocation list lives in SQLite on the container, so a revoked JWT passes the edge and is rejected by Express.</p><p>At launch, API Gateway reached the container over the public internet: the instance’s port 8000 was open on its public IP, and the gateway’s origin URL pointed at it. Anything that found the IP could skip the gateway, so the container had to reject a bad token on its own. I’ve since closed the port entirely (API Gateway reaches the container only through the Access-restricted Cloudflare Tunnel, and admin traffic goes over Tailscale), and the Express layer is still required: it’s the only layer the Render and Railway deploys have. The one route neither layer checks is /healthz, because docker-compose healthchecks don&#39;t carry a token.</p><p>The logs show the layering doing its job. The audit covered two non-overlapping 30-day windows (my CloudWatch retention was 30 days at the time, so the eras were audited separately). The unattributed traffic added up to 17 requests from 9 IPs (Cloudflare’s own scanner, browser favicon fetches, a few curls), and the edge rejected every one of them. The only rejections at the Express layer were two verification probes I sent over Tailscale, deliberately behind the gateway, with a bad token: the gateway and the Lambda never saw them, and Express rejected them.</p><figure><img alt="Rejection counts by layer: API Gateway about 1,160, Lambda authorizer 0 of 23,619, Express 2" src="https://cdn-images-1.medium.com/max/1024/1*lnWctfCwugTXdFZ31fU8KA.png" /></figure><figure><img alt="Request path in the AWS reference deployment with rejection counts at each layer" src="https://cdn-images-1.medium.com/max/1024/1*RpnPUOPD8H-ghCO3CzHUmQ.png" /><figcaption><em>The reference deployment’s request path, with rejection counts for the layers the audit covered (Cloudflare’s WAF wasn’t audited). The purple path is the container-only deploys: same Express auth, nothing in front of it.</em></figcaption></figure><h3>The 30-Line Verifier</h3><p>The JWT code is one file with zero dependencies, and the verifier is about 30 lines of it. The risk in JWT handling is the feature surface a library brings, and the classic attacks (algorithm confusion and alg: none) can&#39;t happen here: the verifier accepts HS256 only, computes the expected signature directly, and compares. There&#39;s no alg header parsing for an attacker to manipulate, because nothing in the token changes how it&#39;s verified. I used Node built-ins to accomplish the task. The verifier uses crypto.createHmac (OpenSSL underneath) over three base64url segments and crypto.timingSafeEqual to compare them.</p><p>My practical reasoning was the Lambda bundle. The authorizer imports verifyJwt, and every dependency in that file grows the deployment package; a 200KB library for one algorithm didn&#39;t seem worth it. Here is the comparison logic:</p><pre>const sigBuf = Buffer.from(sig, &quot;base64url&quot;)<br>const expBuf = Buffer.from(expected, &quot;base64url&quot;)<br>if (sigBuf.length !== expBuf.length) return null<br>if (!timingSafeEqual(sigBuf, expBuf)) return null</pre><p>timingSafeEqual runs in constant time, so an attacker can&#39;t measure how much of a forged signature is right and iterate toward a valid one. The length pre-check is there because the function throws on unequal buffers, and a throw here would surface as a 500 instead of a 401. The timing side channel is worth closing even on a single-user server: the endpoint is public, and I can&#39;t assume nobody will probe it.</p><h3>Refresh Tokens: Four Versions</h3><p>Refresh tokens are where the design moved the most: four versions since launch.</p><figure><img alt="Four refresh token versions: v1 no expiry, v2 60-day sliding window, v3 HMAC-keyed and client-bound, v4 reuse revokes the whole grant" src="https://cdn-images-1.medium.com/max/1024/1*ccpt_nJb__5gHNM-yM_ONw.png" /></figure><p>Under the launch version, a leaked refresh token that was never used stayed valid indefinitely. I then added a 60-day sliding window which fixed that: each use still rotates the token and now also extends the window, so a daily client never sees expiry and a dormant one is asked to consent again. Sixty days covers a multi-week trip with margin (the system was dogfooded on a 15-day trip, so that case wasn’t hypothetical) and limits how long a leaked token stays useful while its client is idle. The migration set expires_at INTEGER NOT NULL DEFAULT 0, treated every pre-migration row as already expired. This meant one forced re-auth for active sessions, rather than backfilling an expiry onto rows that were issued without one.</p><p>The third version, in August, changed what the database holds. Until then it stored refresh tokens in plaintext, and rotating the static token, which also signs every JWT, didn’t revoke them: a connected client would silently mint new JWTs under the new secret. Now each row is keyed by HMAC-SHA256(secret, token), so the database never holds a token anyone could present. Refresh tokens are also bound to the client that registered them, which the <a href="https://datatracker.ietf.org/doc/html/draft-ietf-oauth-v2-1-15#section-4.3">OAuth 2.1 draft</a> makes a MUST. The upgrade cleared four plaintext rows, the same one-time trade as the first migration. Secret rotation is covered by an integration test that boots the server under one secret, reboots it under another, and asserts that the old refresh token gets invalid_grant, the old access token gets a 401, and a fresh consent succeeds.</p><p>Using the static token as the signing key might look like the wrong choice: it’s the credential that leaves the server (it gets pasted into config files and typed into the consent page), so a signing key that never leaves the server looks safer. But the static token by itself is already full API access on this server. An attacker holding it doesn’t need to sign JWTs, so a second secret wouldn’t remove a risk; it would add a second thing to rotate. In return, rotation revokes everything in one step: it invalidates the JWTs (signed with it) and orphans every refresh row (keyed by it), so no session survives a rotate and redeploy. It does mean every issued JWT is a sample of the key for an offline guesser, so the token can’t be a password anyone chose: the CLI generates it as 32 random bytes (the manual guides say openssl rand -hex 32), which puts brute force out of reach.</p><p>The fourth version closed the reuse gap. Every refresh rotates the token, so a token presented a second time means either a stolen copy in play or a client that lost the response, and the <a href="https://datatracker.ietf.org/doc/html/draft-ietf-oauth-v2-1-15#section-7.5.2">OAuth 2.1 draft</a> has the server revoke the whole grant either way. Until this version, a replay got invalid_grant and nothing else, because the row was deleted on first use. Now the replay costs the client its grant, and the next use asks for consent again.</p><p>Over 59 days of logs under the second version there have been 75 silent refreshes across 9 clients, zero refresh failures, zero expiry-driven re-consents, and the longest gap between uses is 26 days. There’s been one forced re-auth on record, when the data volume was wiped on purpose during local testing.</p><h3>What Production Changed</h3><p>The core OAuth 2.1 flow has held up in production. Once real clients were on it, four things prompted changes around the edges: a gateway setting turned 401 into a 403, which claude.ai reported as a connection issue on every add, a run of 404s observed from a discovery path that the <a href="https://www.rfc-editor.org/info/rfc9728/">spec names</a> and the server didn’t serve, a rate limiter that trusted a header it shouldn’t have, and a scanner report that, though mostly false positives, surfaced one real finding.</p><h3>The 403 claude.ai Reported as a Connection Issue</h3><p>Adding the server in claude.ai showed a “Connection issue” status instead of the connect prompt, while Claude Code and Claude Desktop worked. The connector could still be added and connected by hand, so this was a wrong status on every add rather than a lockout, and I wanted to know where the status came from. My first suspect was the new Cloudflare-proxied custom domain, so I isolated it: pointed requests at the gateway’s raw execute-api URL with --connect-to (that hostname was still open in June; it&#39;s disabled now), bypassing Cloudflare entirely, and got identical 403s, so I knew the domain wasn&#39;t the problem.</p><p>The cause was a status code. MCP clients start the OAuth flow from a 401: no token means a 401, and the 401 is what starts discovery. When an AWS HTTP API’s Lambda authorizer denies a request, the gateway answers with a 403, and HTTP APIs have <a href="https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-vs-rest.html">no Gateway Responses</a> to reshape it. The <a href="https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-lambda-authorizer.html">documented ways</a> to get a 401 out of an HTTP API are a missing identity source, which makes the gateway reject the request before the Lambda runs, or the Lambda raising its own Unauthorized error. Claude Code accepts either status. claude.ai requires the 401, and <a href="https://claude.com/docs/connectors/building/authentication">its connector docs say so</a> in those words. The authorizer&#39;s identity source had been left empty on purpose, to let the unauthenticated discovery paths reach the Lambda. That meant the Lambda ran on every tokenless request, denied the ones to /mcp, and the gateway turned each deny into a 403. It went unnoticed for a month because established connections never broke: refresh uses the open /token route, so only a first tokenless request (a new connector, a fresh install) ever saw it.</p><p>The fix was the identity source: registering the Authorization header as the authorizer&#39;s identity source and splitting the routes, so tokenless requests to /mcp get an automatic 401 from the gateway before the Lambda is invoked, and the discovery routes stay open as the MCP spec requires. A tokenless probe now costs no Lambda invocation at all. I considered a Cloudflare Worker rewriting 403 to 401 (patching the symptom) and migrating to AWS REST APIs for Gateway Responses (a larger migration than the problem justified), and rejected both. The status code is part of the API contract, and two clients reading the same MCP spec disagreed about it.</p><h3>The 404s That Were a Spec Gap</h3><p>The second finding came from a client that was following RFC 9728 more closely than my server was. In early August, Perplexity started getting 404s from the server, 63 of them in two days, and at that rate it looked like a misconfigured client. The paths said otherwise. Every request was for /.well-known/oauth-protected-resource/mcp, the path-suffixed discovery URL that <a href="https://www.rfc-editor.org/rfc/rfc9728">RFC 9728</a> makes the canonical location for a resource served under a path, and the server only answered at the root document. I added the suffixed route, and the 404s stopped, and there have been none since.</p><h3>Rate Limiting Behind a Proxy</h3><p>In August a security researcher reported, through GitHub’s private vulnerability reporting, that the rate limiter keyed its bucket on the client-supplied Forwarded header without checking that the header came from a trusted proxy. An attacker could open a fresh bucket per request, and since /register is unauthenticated by design, the limiter was the only control in front of unbounded database writes. The report came with a working proof of concept against the stock Docker image: six control requests, the sixth got a 429; six spoofed requests, all six passed. That left twelve rows in the clients table: one from a pre-test check, five from the control run, and six from the spoof.</p><p>The bypass was older than the limit. Since launch day in May, the bucket key had trusted whatever Forwarded header arrived, because I had assumed API Gateway would be the one writing it. That assumption held on my own deployment and nowhere else: on a directly exposed container, a tunnel, or a reverse proxy that passes the header through, nothing writes that header except the client, and the proof of concept ran against exactly that, the stock image with no proxy in front of it. Tightening every OAuth endpoint to 5 requests a minute on August 7 (they had run on the SDK&#39;s looser defaults until then, <a href="https://github.com/modelcontextprotocol/typescript-sdk/blob/1.30.0/src/server/auth/handlers/register.ts#L62-L70">20 registrations an hour</a> for one) changed nothing about it.</p><p>The fix is a trust gate, off by default. Before it, extractClientIp used the Forwarded header&#39;s first for= value whenever the header was present, from any peer, on any deployment. Now two settings, TRUST_PROXY_HOPS and TRUST_FORWARDED_HOPS, state how many proxy hops a deployment trusts for each header family, and both default to zero. At zero the header is ignored and the bucket keys on the TCP peer, which an attacker can&#39;t choose, so the stock image the researcher tested is closed without any configuration. An operator who does put a proxy in front opts in with the real hop count.</p><p>Once trust is on, the parser reads from the end of the chain rather than the start, as many entries in as the deployment says it trusts, because the trailing entries are the proxies’ own claims and a client can’t write those. The case that makes this necessary is API Gateway itself: it discards a client-sent Forwarded header but folds a spoofed X-Forwarded-For into the Forwarded chain it writes, ahead of the real peer ( <a href="https://github.com/aliasunder/vault-cortex/blob/main/ARCHITECTURE.md#auth-oauth-21--defense-in-depth">the behaviour is documented in ARCHITECTURE.md</a>), so a first-element read would key the bucket on the spoof even on my own path.</p><figure><img alt="TRUST_FORWARDED_HOPS settings: 0 keys on TCP peer, 1 keys on the gateway’s entry, 2 keys on the second-to-last entry behind Cloudflare" src="https://cdn-images-1.medium.com/max/1024/1*CKDdiyGXSvWRvslb7pGWjg.png" /></figure><figure><img alt="Reading the last element of the X-Forwarded-For chain instead of the first defeats header spoofing" src="https://cdn-images-1.medium.com/max/1024/1*oud5SJHAod-uuxHW1d1eCg.png" /><figcaption><em>The gateway path with trust turned on. The gateway appends its own claim, so the last entry is the one an attacker can’t forge. With trust at its default of zero, none of this header is read at all.</em></figcaption></figure><p>I <a href="https://github.com/aliasunder/vault-cortex/security/advisories/GHSA-wm5v-9236-597m">published the advisory</a> the same day, rated high severity and crediting the reporter, and shipped the fix as a security release. Five per minute has also proved loose enough for real clients. A complete OAuth flow touches each endpoint at most twice, and the heaviest burst on record, a reconnect firing four registrations, two authorizes and two token exchanges in 40 seconds, passed without a single throttled request. A later change capped the row count as well. Registrations older than a week holding no unexpired refresh token are swept at boot and before each new registration, so the limiter limits how fast rows appear and the sweep limits how long they stay. At 5 a minute, one address can add about 7,000 rows a day, and each of them is gone a week later.</p><h3>The Grade F</h3><p>The last production change came from outside the traffic: this summer I found a Grade F for the server on the first page of Google. A scanner site I’d never heard of had scanned the repo and graded it F, with a score of zero out of a hundred, and 438 vulnerabilities. Here are just four of the false results: import statements from the MCP SDK were flagged as hardcoded credentials (CVSS 9.1), a setTimeout promise was flagged as an eval() with external input (9.8), and two parameterized prepared statements were flagged as an exposed API key (8.5). Every other server I sampled in its registry had scored the same zero since late June. I disputed it with the operator, the page came down within a day, and Google eventually dropped it.</p><p>I’m not naming the scanner, because the problem is the genre: a <a href="https://arxiv.org/abs/2607.11086">July 2026 study</a> ran 37,288 MCP servers through eight popular scanners and found average precision of 45.5%. Sifting a second report, a C from a different site and again mostly false positives, still surfaced one real gap, which did result in a change: I added comprehensive OAuth audit logging, including 14 event types covering registration, authorization, PKCE outcomes, grants, and revocations. (The repo’s own CI runs CodeQL, Socket Security, Gitleaks, Trivy, OpenSSF Scorecard, and Dependabot, and releases are cosign-signed into a public transparency log.)</p><h3>One Scope, Two Spec Items Closed</h3><p>Reflecting on three months of production use, I’d keep the single scope. The server advertises one, vault, and no layer checks it, because there&#39;s only one level of privilege for a check to decide between. READONLY_MODE and DISABLED_TOOLS limit what a token can do at the tool layer, which is the risk that actually exists here. The consent page is the other thing I&#39;d leave as it is: no account to sign in to, nothing for the page to remember, and approving checks only that the authorization request is still pending and the token matches the server&#39;s own.</p><p>Two spec items closed late, one from each spec. The audience item is a MUST the <a href="https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization#token-handling">MCP spec</a> adds on top of OAuth 2.1: a server has to validate that its tokens were issued specifically for it. For three months the access token carried no audience claim, and the issuer claim it did carry was never compared to anything. The per-deployment signing key meant a token only verified on the server that minted it, which is most of what audience binding buys, but two deployments sharing the same secret would have accepted each other’s tokens. Tokens now carry an audience naming the server’s MCP endpoint and an issuer naming its authorization server, both verifiers require them, and a client that names a different server in its <a href="https://www.rfc-editor.org/rfc/rfc8707">RFC 8707</a> resource parameter gets invalid_target instead of a token. The checks were a few lines in the verifier. The rollout was the harder part: a token minted before the upgrade carries no audience, and rejecting it at the gateway would strand the client, because a gateway deny is the fixed 403 <a href="https://aliasunder.dev/posts/oauth-2-1-for-a-personal-mcp-server/#the-403-claudeai-reported-as-a-connection-issue">from earlier</a> and clients refresh only on a 401. So the gateway passes pre-upgrade tokens through temporarily, Express answers them with the 401 that triggers a silent refresh, and the gateway will make this contract strict in a later release.</p><p>The other item was the OAuth 2.1 draft’s reuse rule, closed by the fourth refresh-token version ( <a href="https://aliasunder.dev/posts/oauth-2-1-for-a-personal-mcp-server/#refresh-tokens-four-versions">above</a>): a rotated refresh token presented a second time now revokes the whole grant. Before that version, a replay got invalid_grant and nothing else.</p><h3>Try It</h3><p>Vault Cortex is open source: <a href="https://github.com/aliasunder/vault-cortex">github.com/aliasunder/vault-cortex</a>. Quick start is npx vault-cortex@latest init. This post is the explanation, not the setup guide: everything here except the AWS edge ships in the container by default. If AWS isn&#39;t your preferred provider, the <a href="https://github.com/aliasunder/vault-cortex/blob/main/deploy/remote/README.md">remote guide</a> covers any VPS that runs Docker, with a <a href="https://github.com/aliasunder/vault-cortex/blob/main/deploy/remote/README.md#hardening-recommended">Hardening section</a> for anything more than the container&#39;s own auth. In addition, the <a href="https://github.com/aliasunder/vault-cortex/blob/main/deploy/render/README.md">Render</a> and <a href="https://github.com/aliasunder/vault-cortex/blob/main/deploy/railway/README.md">Railway</a> guides have one-click deploys, and the README has a <a href="https://github.com/aliasunder/vault-cortex#remote-access-from-anywhere">comparison table for the 4 remote paths</a>.</p><p>The README also has a <a href="https://github.com/aliasunder/vault-cortex#community-deployments">Community deployments</a> section for templates other people have built, with the first entry being an Azure Container Apps template by <a href="https://github.com/flytzen">@flytzen</a>. If you build one for another platform, open a PR and I’ll add it.</p><p>This is the second post in a series about building a personal AI memory system. <a href="https://medium.com/@aliasunder/i-gave-claude-access-to-my-entire-second-brain-ce23f6d4202c">The first</a> covers what the server is for and how it held up over 15 days of travel. Next up: the search layer, SQLite FTS5 plus local embeddings.</p><p><em>Originally published at </em><a href="https://aliasunder.dev/posts/oauth-2-1-for-a-personal-mcp-server/"><em>https://aliasunder.dev</em></a><em> on September 1, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c082ee822a8b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mcp-server/oauth-2-1-for-a-personal-mcp-server-what-three-months-in-production-changed-c082ee822a8b">OAuth 2.1 for a Personal MCP Server: What Three Months in Production Changed</a> was originally published in <a href="https://medium.com/mcp-server">MCP-Server</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Ignored MCP. Then I Watched It Get Declared Dead. Here’s What Actually Happened.]]></title>
            <link>https://medium.com/mcp-server/i-ignored-mcp-then-i-watched-it-get-declared-dead-heres-what-actually-happened-fb164fa7c7c4?source=rss----3625a908dd02---4</link>
            <guid isPermaLink="false">https://medium.com/p/fb164fa7c7c4</guid>
            <category><![CDATA[agents]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[model-context-protocol]]></category>
            <category><![CDATA[mcp-server]]></category>
            <dc:creator><![CDATA[Jamieparker]]></dc:creator>
            <pubDate>Mon, 10 Aug 2026 20:23:33 GMT</pubDate>
            <atom:updated>2026-08-10T20:23:30.008Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Editorial illustration of MCP connecting an AI agent to multiple tools and services, representing the debate over whether the Model Context Protocol is dead or becoming standard AI infrastructure." src="https://cdn-images-1.medium.com/max/1024/1*U-896J3ErfMTipEQ5tnmIA.png" /></figure><p>When Anthropic quietly open-sourced the Model Context Protocol in November 2024, I skimmed past it. Another open standard. Another thing to bookmark and never read.</p><p>By mid-2025, I’d changed my mind. By March 2026, I was watching developer Twitter declare it dead. And by now, having seen both the hype and the backlash, I think I understand what MCP actually is and isn’t. That’s different from what either side of the debate was arguing.</p><h3>The Death Announcement</h3><p>On March 11, 2026, Perplexity CTO Denis Yarats said at Ask 2026 that the company was moving away from MCP internally, favoring APIs and CLIs for parts of its agent infrastructure.</p><p>Within days, “MCP is dead” became a recurring theme across developer discussions.</p><p>Eric Holmes published “MCP is dead. Long live the CLI,” arguing that CLIs were simpler, more reliable, and more token-efficient for many agent workflows. Garry Tan also criticized MCP’s context-window usage and authentication experience. Thoughtworks had already put “naive API-to-MCP conversion” in the Hold category of its Technology Radar, warning that blindly exposing existing APIs through MCP can create excessive token usage, context pollution, and security problems.</p><p>The criticism was technically specific, not just vibes.</p><p>One widely circulated analysis measured three MCP servers consuming 143,000 of a 200,000-token context window before the agent had done any meaningful work. Another benchmark comparing MCP with CLI-based workflows found substantially higher token consumption for MCP in the tested scenarios.</p><p>Those are real problems.</p><p>But two things about that moment deserve more scrutiny than they got.</p><p>First, the 72% figure that circulated alongside the Perplexity story came from an external analysis, not from Perplexity’s own internal measurement. That’s an important distinction. “Perplexity proved MCP wastes 72% of context” and “one configuration consumed 72% of a 200K context window” are very different claims.</p><p>Second, context overhead isn’t an unavoidable property of MCP itself. A major part of the problem is how clients discover and load tools. If an agent loads every tool definition from every connected server at startup, the context cost can become enormous. Progressive or deferred discovery changes that equation by loading capabilities when they’re actually needed.</p><p>The critics were right that naive MCP implementations can be expensive.</p><p>They were wrong to treat that implementation pattern as the protocol’s inevitable economics.</p><h3>Why the Backlash Was Always Going to Happen</h3><p>MCP’s adoption curve was unusually fast.</p><p>By December 2025, Anthropic reported more than 97 million monthly SDK downloads and 10,000 active servers, along with first-class support across major AI clients.</p><p>That kind of growth creates an obvious problem: a lot of developers end up building production systems around a protocol while the ecosystem is still figuring out what good production implementations look like.</p><p>The ecosystem also developed the quality problem you’d expect from explosive open-source growth.</p><p>Quantity of servers does not imply reliability.</p><p>Some public MCP servers were written quickly, maintained by small teams, or never properly audited. When teams wired those servers into production and things broke, some of the criticism aimed at MCP was deserved.</p><p>But not all of the resulting pain was actually caused by the protocol.</p><p>Thoughtworks’ warning is a good example. Its Technology Radar didn’t say “MCP is broken.” It specifically warned against naively converting existing APIs into MCP servers because APIs designed for human developers can expose too many granular operations, consume excessive context, and create security risks when handed directly to autonomous agents.</p><p>That’s a very different criticism.</p><p>The protocol itself was also evolving. Teams deploying MCP in late 2025 weren’t necessarily using the same specification, transports, authentication patterns, or client implementations that existed at launch in November 2024.</p><p>Some of the “MCP is broken” complaints were really:</p><p><strong>“The MCP ecosystem is still maturing.”</strong></p><p>There’s a difference.</p><h3>What Was Actually Happening Underneath the Discourse</h3><p>While the death notices were being written, something much more consequential was happening on the governance side.</p><p>In December 2025, Anthropic donated MCP to the newly formed Agentic AI Foundation under the Linux Foundation. OpenAI and Block were among the foundation’s founding participants, alongside major industry members including Amazon Web Services, Google, Microsoft, Bloomberg, and Cloudflare.</p><p>The important part isn’t the foundation’s name.</p><p>It’s what the move represents.</p><p>MCP was no longer just an Anthropic project. It was being placed under a neutral, open foundation with participation from companies competing across the AI stack.</p><p>That’s a significant signal.</p><p>It doesn’t mean MCP is guaranteed to win. It doesn’t mean the protocol is finished. And it certainly doesn’t make every implementation good.</p><p>It means the industry has enough interest in standardized agent-to-tool interoperability that keeping the protocol vendor-neutral has become strategically valuable.</p><p>And the original problem MCP was solving hasn’t gone away either.</p><p>Before MCP, connecting AI applications to external systems created an N×M integration problem. Ten AI applications and 100 tools could mean up to 1,000 separate integrations, each with its own authentication, schemas, error handling, and maintenance.</p><p>MCP changes the architecture toward N+M.</p><p>Instead of building a custom connector for every AI-to-tool pairing, each client implements MCP and each tool exposes an MCP server.</p><p>The exact savings depend on the architecture, but the underlying idea is straightforward:</p><p><strong>Standardize the connection layer once instead of rebuilding it repeatedly.</strong></p><p>That math doesn’t stop being useful because one company chose APIs or CLIs for a particular workload.</p><h3>What the Architecture Problem Actually Looks Like in Production</h3><p>A pattern I’ve repeatedly seen in AI projects is simple:</p><p><strong>The models are fine. The architecture is a mess.</strong></p><p>Dozens of custom connectors, each maintained separately.</p><p>Authentication that breaks when a third-party API changes.</p><p>No central place to observe what an agent is doing or why it failed at step four of nine.</p><p>Integration debt that compounds every time a new tool gets added.</p><p>The instinct is to fix connectors one at a time.</p><p>The better move, when the workload actually benefits from a shared tool interface, is to standardize that communication layer rather than keep building bespoke integrations.</p><p>MCP doesn’t eliminate authentication, permissions, rate limits, security, monitoring, or observability.</p><p>What it can do is give those concerns a common integration surface instead of scattering custom connection logic across every AI application.</p><p>Consider an agent handling an engineering incident.</p><p>It reads the alert from PagerDuty, pulls recent deploy information from GitHub, queries the observability platform for the spike, cross-references an internal runbook, opens a Jira ticket, and posts a summary to Slack.</p><p>Each step calls a different capability. Each step can feed information into the next.</p><p>Without a shared protocol, that chain can become a collection of custom integrations.</p><p>With MCP, each system can expose a standardized server interface and the agent can interact with them through the same protocol.</p><p>That’s the part of MCP that still makes sense to me.</p><p>And it’s also where the architecture starts getting interesting in practice. Instead of building and maintaining a separate MCP server or connector for every tool, a unified gateway can provide a single connection layer across multiple services. <a href="https://mcp360.ai/">MCP360</a> takes this approach with a unified AI gateway that gives agents access to a broad set of production-ready tools through one integration layer.</p><p>The underlying idea is simple: reduce the number of connections your team has to build and maintain as the number of tools grows.</p><h3>MCP vs. APIs vs. CLIs Isn’t a Winner-Take-All Fight</h3><p>This is also where I think the “MCP is dead, use CLIs” argument goes too far.</p><p>CLIs are excellent when the operation is deterministic, composable, and already has a good command-line interface.</p><p>APIs are often the obvious choice when you’re building a direct application-to-service integration.</p><p>MCP becomes more interesting when an agent needs to discover and use capabilities across many heterogeneous systems through a common interface.</p><p>Those aren’t mutually exclusive.</p><p>A good architecture might use all three.</p><p>The mistake is assuming one interface has to replace the others.</p><p>The better question is:</p><p><strong>Which interface gives the agent the right capabilities with the least unnecessary complexity?</strong></p><p>For some workflows, that’s a CLI.</p><p>For others, it’s an API.</p><p>For others, MCP makes sense precisely because the agent needs a standardized way to discover and invoke capabilities across different systems.</p><p>That’s a much more useful debate than asking whether MCP is “dead.”</p><h3>Where It Stands Now</h3><p>By late 2025, MCP had already reached more than 97 million monthly SDK downloads and 10,000 active servers according to Anthropic.</p><p>By 2026, the ecosystem had become much larger and more fragmented, with different registries and aggregators reporting different server counts. Those numbers aren’t directly comparable because they don’t all count the same things.</p><p>And server count alone doesn’t tell you how healthy the ecosystem is.</p><p>Ten thousand poorly maintained servers aren’t more valuable than a thousand reliable ones.</p><p>The more interesting shift is in the questions developers are asking.</p><p>The debate is moving away from:</p><p><strong>“Should we use MCP?”</strong></p><p>and toward:</p><p><strong>“How should we load tools efficiently?”</strong></p><p><strong>“How do we govern agent access across dozens of servers?”</strong></p><p><strong>“How do we audit what an agent actually did?”</strong></p><p><strong>“When should we use MCP instead of an API or CLI?”</strong></p><p>Those are better questions.</p><p>They’re the questions you get to ask once the protocol war becomes less important than the architecture around it.</p><p>The critics who said MCP was too token-expensive in its naive form were right.</p><p>The critics who said that made the protocol fundamentally broken were wrong.</p><p>And the teams that kept building, fixed their client implementations, reduced tool-loading overhead, and moved on to harder problems may end up ahead of the teams that ripped MCP out entirely and then had to recreate a standardized integration layer themselves.</p><p>MCP is not going to be interesting for much longer.</p><p>It’s going to be plumbing.</p><p>And plumbing is exactly what it was always supposed to become.</p><p><em>Sources: Anthropic’s December 9, 2025 announcement on MCP joining the Agentic AI Foundation, which reported more than 97 million monthly SDK downloads and 10,000 active servers. Context-window figures are based on independent analyses and should not be interpreted as universal MCP costs. Thoughtworks Technology Radar for its assessment of naive API-to-MCP conversion. Eric Holmes’ “MCP is dead. Long live the CLI,” published in February 2026. Perplexity CTO Denis Yarats’ March 2026 comments concerned Perplexity’s internal architecture rather than a claim that MCP was being abandoned industry-wide.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fb164fa7c7c4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mcp-server/i-ignored-mcp-then-i-watched-it-get-declared-dead-heres-what-actually-happened-fb164fa7c7c4">I Ignored MCP. Then I Watched It Get Declared Dead. Here’s What Actually Happened.</a> was originally published in <a href="https://medium.com/mcp-server">MCP-Server</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My Support Bot Kept Hallucinating. The Problem Wasn’t the Model.]]></title>
            <link>https://medium.com/mcp-server/my-support-bot-kept-hallucinating-the-problem-wasnt-the-model-98501f2c5c37?source=rss----3625a908dd02---4</link>
            <guid isPermaLink="false">https://medium.com/p/98501f2c5c37</guid>
            <category><![CDATA[model-context-protocol]]></category>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[a2a-protocol]]></category>
            <category><![CDATA[multi-agent-systems]]></category>
            <category><![CDATA[protocol]]></category>
            <dc:creator><![CDATA[Jamieparker]]></dc:creator>
            <pubDate>Tue, 04 Aug 2026 15:40:54 GMT</pubDate>
            <atom:updated>2026-08-04T15:40:53.251Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Building Production Multi-Agent Workflows" src="https://cdn-images-1.medium.com/max/1024/1*Dp7dQyi7cOywR_XpU7QNsw.png" /></figure><p><strong>Six weeks of debugging later, I finally understood what single-agent architecture actually costs, and what two protocols do about it.</strong></p><p>The support bot worked fine in testing.</p><p>By week two in production, it was confidently citing account details that didn’t exist. Not sometimes. Consistently, by step three of every multi-step flow. I blamed the prompt, then the model, then the temperature setting. None of it fixed anything.</p><p>The actual problem was architectural. The agent was doing triage, pulling CRM data, drafting responses, and updating the ticketing system, all inside one context window. By the time it got to drafting, the account data it retrieved four steps earlier had been pushed out by everything added since. It wasn’t hallucinating. It was working with what it could still see.</p><p>That failure sent me six weeks deep into multi-agent design. This is what I found.</p><h3>What Actually Goes Wrong With a Single Agent</h3><p>“Context window limits” is too vague to be useful. The real failure modes are more specific, and they build on each other.</p><p><strong>The window fills up faster than you think: </strong>Each tool call adds tokens. Pull CRM data, check ticket history, fetch a knowledge base article, and you’ve burned a substantial portion of the available window before any reasoning starts. The model’s early outputs don’t disappear cleanly. They erode. Later steps work with fragments of what was retrieved rather than the full picture.</p><p><strong>A wrong output in step one travels silently to every step that follows: </strong>With a shared context, a misclassification in triage rides forward unchallenged. There’s no structural boundary that catches it.</p><p><strong>Independent operations still run sequentially:</strong> Fetching a user account and pulling their transaction history don’t depend on each other. In a single-agent setup they run one after the other anyway, because they share a prompt queue. Two waits where one parallel wait could work.</p><p><strong>Control flow is implicit:</strong> There’s no explicit logic deciding what runs when. Steps skip or repeat without announcing either failure.</p><p><strong>Intermediate results have nowhere to live:</strong> Outputs from step two either bloat the context forward or get regenerated from scratch at step four. Both options cost tokens. Both cost money. A Gartner-cited analysis of enterprise deployments found one team’s workflow costing $0.50 in testing hit $50,000 per month at scale, largely because intermediate work kept being regenerated.</p><p>None of this makes single agents wrong. For a contained task, one agent is exactly right. The problems above surface specifically when a workflow touches multiple external systems, has dependent steps, and has operations that could run in parallel. At that point the architecture needs a different shape.</p><h3>Two Protocols, Two Layers</h3><figure><img alt="MCP and A2A Architecture" src="https://cdn-images-1.medium.com/max/1024/1*pJIm0AamtwzAhwN9tYiiUg.png" /></figure><p>The solution isn’t just “use multiple agents.” It’s understanding that a multi-agent system has two separate concerns, and they need separate protocols.</p><p><strong>MCP (Model Context Protocol)</strong> is the vertical layer. It standardizes how each individual agent connects to its tools, APIs, and data sources. Anthropic released it in late 2024. Before MCP, connecting five AI agents to twenty tools meant managing up to 100 different integration points. MCP collapses that to one standard interface per side: build a tool as an MCP server once, and any compatible agent can use it without custom wiring.</p><p><strong>A2A (Agent2Agent Protocol)</strong> is the horizontal layer. It handles how agents talk to each other, delegating tasks, streaming results, passing context between workflow steps. Google launched it in April 2025, donated it to the Linux Foundation two months later, and it reached v1.0 stable in early 2026 with confirmed production deployments across major enterprise vendors including Microsoft, AWS, and Salesforce. Version 1.0 added Signed Agent Cards, which let a receiving agent cryptographically verify that a card came from the actual domain owner rather than a forged source.</p><p>The reason you need both is that they operate at different levels. Update an external API and you touch only MCP. Reroute how agents delegate and you touch only A2A. Neither update reaches the other layer. That independence is what makes the stack maintainable as the system grows.</p><h3>Tracing a Real Workflow</h3><p>The clearest way to internalize the split is to watch it move through an actual task.</p><p>Take the support flow I was rebuilding. A ticket comes in.</p><p><strong>Step 1:</strong> The orchestrator, whose only job is routing, sends the ticket to a triage agent over A2A. The triage agent classifies it as billing, technical, or account-related, and extracts fields like user ID, product area, and severity. It returns a structured object. It queries nothing external. It classifies.</p><p><strong>Step 2:</strong> The orchestrator forwards that to a retrieval agent, again over A2A. The retrieval agent uses MCP to query the CRM, the ticketing system, and the knowledge base, in parallel where possible. It packages what it finds into one context object and returns it.</p><p><strong>Step 3:</strong> A resolution agent takes that context, drafts the response, and recommends a next action. If it needs to verify something, refund eligibility for instance, it queries the billing system through MCP. It returns both the response text and the suggested action.</p><p><strong>Step 4:</strong> An action agent applies the output: updates the ticket, triggers downstream processes, logs the outcome.</p><p>A2A carries tasks and results between agents. MCP handles tool access inside each one. The orchestrator touches neither a database nor a tool directly. Every step has one owner, one input, one output.</p><p>When something breaks, you find it at the boundary where it happened. Not buried inside a 200K-token context.</p><h3>The Security Layer Most Teams Skip</h3><p>Running agents that can discover each other and delegate work opens attack surface that a single agent doesn’t have. The most counterintuitive vulnerability is at discovery itself.</p><p>Orchestrators choose which specialist to route to by reading Agent Card descriptions. A rogue agent can publish a card with text crafted to manipulate that selection logic, a prompt injection that operates before any task runs, hijacking routing through language in a capability field. Security researchers have documented this exact vector. A2A v1.0’s Signed Agent Cards address card spoofing by adding cryptographic verification. They don’t remove the need to scrutinize what an agent claims it can do beyond the signature.</p><p>Three practices carry most of the weight, and I’d set all three up before going near production.</p><p>First, verify Agent Card signatures rather than trusting the text. Keep an allowlist of known agent identities and don’t accept cards from unknown sources automatically. Second, scope credentials per agent using OAuth 2.0 machine-to-machine tokens, short-lived, automatically rotated, and limited to specific endpoints. Third, instrument every agent boundary with distributed tracing using W3C traceparent headers. When a request fans out through four agents and fails, traces are the only way to reconstruct what actually happened.</p><p>On the MCP side, centralizing tool access means a misconfigured permission can expose more than intended. When access breaks in a multi-agent system, the cause is almost always the connection and its permissions, not the model’s reasoning. Start debugging at the gateway, not the prompt.</p><h3>The Layer That Decides How Fast You Can Scale</h3><p>A2A gets the attention because it’s the newer piece. In a real build, the layer that determines how fast you can add the next agent is the tool layer underneath all of them.</p><p>The workflow above ran on four agents, each reaching its own tools through MCP. Add two more next quarter and, in a naive build, that’s two more rounds of integrations, credentials, and upkeep. A2A scales cleanly because it’s standardized. The tool layer only scales cleanly if you standardize it the same way.</p><p>This is where a unified MCP gateway, <a href="https://mcp360.ai/">MCP360 </a>the one I use, makes a real difference. Instead of each agent maintaining its own integrations, every agent connects to one gateway and loads only the tools it needs for the current task on demand. One team I came across halved their effective per-agent context usage by lazy-loading tool definitions rather than dumping the full tool manifest into every session. It also means adding a new agent next quarter doesn’t mean a new integration project. The catalog is already there.</p><p>MCP360 doesn’t handle A2A orchestration, that stays in your own stack. It handles the MCP layer: routing, authentication, and tool access across all agents from one place.</p><h3>What This Architecture Actually Buys You</h3><p>A properly structured multi-agent stack gives you three concrete things.</p><p><strong>Testability per step: </strong>Because every agent has a defined input and output, you can test, swap, or upgrade one without touching the rest. That’s not possible when everything shares a context.</p><p><strong>Parallel execution:</strong> Steps that don’t depend on each other run at the same time. The retrieval agent doesn’t wait for the triage agent to fully finish if what it needs is already available.</p><p><strong>Inspectable failures:</strong> Intermediate outputs exist as structured artifacts outside any single agent’s context. When something breaks, you inspect the output at each boundary, not reconstruct events from a 150K-token context dump.</p><p>What it doesn’t do is decide whether a workflow was worth building. Gartner projects that over 40% of agentic AI projects will be cancelled by the end of 2027, driven by unclear business value and weak governance, not protocol immaturity. A clean two-protocol stack helps with governance because it makes costs observable and failures attributable. It doesn’t make a low-value workflow valuable.</p><h3>Where to Start</h3><p>Map the workflow as discrete steps, each with a single owner, a defined input, and a defined output. Wire those steps between agents over A2A. Standardize the tool layer underneath them through MCP, ideally through a single gateway so you don’t repeat integration work every time you add an agent.</p><p>The two protocols are settled enough now that they’re not the hard part. Deciding which workflows are worth building, and governing them once they’re running, is still where most teams underinvest.</p><p>That judgment the architecture doesn’t make for you.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=98501f2c5c37" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mcp-server/my-support-bot-kept-hallucinating-the-problem-wasnt-the-model-98501f2c5c37">My Support Bot Kept Hallucinating. The Problem Wasn’t the Model.</a> was originally published in <a href="https://medium.com/mcp-server">MCP-Server</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From PowerShell to Prompt: The Quiet End of Scripted SharePoint Governance]]></title>
            <link>https://medium.com/mcp-server/from-powershell-to-prompt-the-quiet-end-of-scripted-sharepoint-cleanup-824b96288f06?source=rss----3625a908dd02---4</link>
            <guid isPermaLink="false">https://medium.com/p/824b96288f06</guid>
            <category><![CDATA[agents]]></category>
            <category><![CDATA[governance]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[mcps]]></category>
            <category><![CDATA[sharegate]]></category>
            <dc:creator><![CDATA[Ragnar Heil]]></dc:creator>
            <pubDate>Thu, 30 Jul 2026 12:28:10 GMT</pubDate>
            <atom:updated>2026-09-23T08:35:53.909Z</atom:updated>
            <content:encoded><![CDATA[<p>Let’s talk about permissions. I know, nobody wakes up excited about permissions. And yet here we are, because on June 23, 2026, <a href="https://sharegate.com/mcp">ShareGate</a> did something genuinely interesting: it taught its governance platform, Protect, to talk. Not in dashboards. Not in PowerShell. In sentences, typed straight into Claude, ChatGPT, or Microsoft Copilot. “Which sites have broken inheritance, who owns them, and when did anyone last touch them?” You ask, it answers — pulling from real tenant data, not guessing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*G4GYsMeAZkurRMZj.png" /><figcaption>ShareGate Protect MCP Integration</figcaption></figure><p><strong>The plumbing: what MCP actually is.</strong> The Model Context Protocol is an open standard Anthropic published in November 2024 to solve what’s politely called the “N×M integration problem”: without a shared protocol, every AI tool needs a custom connector to every data source, and that grid explodes fast. MCP flattens it — a data source implements one server, and any MCP-aware client (Claude, ChatGPT with Developer Mode, Copilot Studio) can talk to it. ShareGate hosts its own server at mcp.sharegate.com/mcp, authenticated via OAuth 2.1 with per-user sign-in — no shared service accounts, no static API tokens floating around. Each user only ever sees, through the AI tool, exactly what they&#39;re already entitled to see inside Protect itself. That last point matters technically: the MCP layer inherits Protect&#39;s existing role-based access model rather than introducing a new, broader trust boundary.</p><p><strong>What ships today (read layer).</strong> Live capabilities include: querying workspaces, sites, Teams, Groups and OneDrives with their owners; enumerating sharing links and permission levels (Anyone / People in org / Specific people); surfacing sensitivity-label coverage and gaps; pulling license assignment and utilization data; producing tenant-health snapshots; filtering and sorting results conversationally; and exporting either to CSV or to a branded, client-logo PDF report — a detail clearly aimed at MSPs and consultants running recurring reviews across multiple tenants. A starter “prompt pack,” co-built with SharePoint MVP Jim Ehrenberg, ships six ready-made read-only prompts: ownerless workspaces, idle/unassigned licenses, “Everyone Except External Users” (EEEU) or All-Company grants, public groups with external sharing enabled, inactive workspaces, and sites with unclear access patterns flagged as high-value.</p><p><strong>What’s rolling out from July 2026 (write layer) — and its guardrails.</strong> This is the part worth reading twice if you’re the one signing off on it: remove sharing links, add or remove group owners, change group visibility, archive or delete sites, delete groups/OneDrives, and create automated remediation policies. Every single action is previewed in plain language before execution — “This will remove 14 Anyone links across 6 sites, affecting these owners” — and requires an explicit human confirmation. New policies are created in a <strong>paused</strong> state by default and must be manually activated; destructive policies carry an additional “I understand the impact” confirmation gate. Every executed change is written to Protect’s standard activity log, tagged with its AI-agent source, so you get the same audit trail you’d get from a manual admin action — nothing bypasses logging just because a chatbot triggered it.</p><p><strong>The genuinely novel piece: cross-server composition.</strong> Because MCP is an open, vendor-neutral protocol, ShareGate’s server can be queried in the same conversation as Microsoft’s own MCP servers — the “Work IQ” activity server and the MCP Server for Enterprise exposing Entra identity and MFA data. ShareGate’s own example query is the clearest illustration: <em>“Find every guest user with access to Finance sites who hasn’t signed in for 90 days and doesn’t have MFA enabled.”</em> ShareGate’s server answers the access-and-sharing half; Microsoft’s server answers the identity-and-MFA half; the AI model stitches the two responses together in one answer. No single vendor’s native tooling does that alone today — Purview knows identity, ShareGate knows sharing, and MCP is the thing that lets an AI agent hold both in its head at once.</p><p><strong>Where this actually beats native tooling — precisely<br></strong>Microsoft’s Purview SharePoint Advanced Management (SAM) has closed a lot of ground: Restricted Access Control, Restricted Content Discovery, Data Access Governance reports, site access reviews. But SAM is scoped to SharePoint and OneDrive only — it has no visibility into Teams chats, Microsoft 365 Groups activity, or Power Platform connectors, and its DAG reports cap out at 28 trailing days of sharing-link activity with up to 48 hours of data lag, refreshed manually rather than conversationally. ShareGate’s MCP advantage, stated precisely, is threefold: <br>(1) <strong>cross-workload unification</strong> — one query surface spanning Teams, SharePoint, Groups, OneDrive and (via composition) Entra, instead of stitching together SAM, the M365 admin center, Entra ID and OneDrive settings by hand; <br>(2) <strong>conversational, script-free remediation</strong> — bulk fixes that would otherwise need PowerShell (Set-SPOSite, Remove-PnPSharingLink and friends) or manual clicking through hundreds of sites, expressed instead as one previewed natural-language action; <br>(3) <strong>agent interoperability</strong> — because it&#39;s built on an open standard rather than a proprietary API, it composes with Microsoft&#39;s own agent ecosystem instead of competing head-on with it.</p><p><strong>How to use it with Copilot Studio</strong></p><ol><li>In <strong>Copilot Studio,</strong> open or create an agent.</li><li>Open the <strong>Tools </strong>tab → <strong>Add a tool </strong>→ under <em>Create new </em>choose <strong>Model Context Protocol.</strong></li><li>Enter <strong>Server name</strong> ShareGate, a server description, and your region&#39;s <strong>Server URL: </strong><a href="https://mcp.eu.sharegate.com/mcp">https://mcp.eu.sharegate.com/mcp</a></li><li>Set <strong>Authentication </strong>to <strong>OAuth 2.0, Type </strong><em>Dynamic discovery.</em> Click <strong>Create</strong>.</li><li>Sign in with your business email and authorize.</li><li>Add the tool to your agent and test: ask,<em>”How many workspaces in my tenant that haven’t had any activity in more than 60 days?”</em></li><li>Publish the agent so your team can reach it in Teams or Microsoft 365 Copilot.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SihAZQjPR3PNhF88a3EraQ.png" /></figure><p>8. Verify: in a chat, turn on the connector and ask,<em>”H</em><strong><em>ow many unassigned E5 licenses do we have?</em></strong><em>”</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F5icLyJeeNA57VQJ3UIOOg.png" /></figure><p>In my next use case I ask for a Purview Sensitvity Label Overview <a href="https://sharegate.com/blog/sharegate-snapshot-july-2026">(July 2026 Update)</a> and receive these results:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2rJaLSF7mrFYaNmISTb_1w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m7BR0cyjDvEGEUOYn78VOg.png" /></figure><p><strong>Which MCP Tools are available?</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/814/1*bXUQE_iX6otYx3VLp72Bhg.png" /></figure><p><strong>What it doesn’t do</strong><br>It’s an operational and visibility layer, not an enforcement layer. It doesn’t sit inside SharePoint’s access-control pipeline the way RAC or RCD does, doesn’t require third-party data processing consent for the underlying platform (SAM doesn’t leave Microsoft’s boundary; ShareGate’s server necessarily does), and doesn’t touch the actual mechanism that keeps content out of Copilot’s index — that’s still Purview’s job. ShareGate itself doesn’t pretend otherwise; its own FAQ describes customers running Protect “alongside Purview and Copilot,” not instead of them.</p><p><strong>My Verdict<br></strong>If your governance headache is <em>visibility fragmented across four admin centers</em> and <em>remediation that requires PowerShell fluency your team doesn’t have</em>, ShareGate MCP is a precise, well-guarded answer: read-first, human-gated writes, full audit logging, and — uniquely — a query surface that composes with Microsoft’s own agents instead of walling itself off. If your headache is <em>enforcement</em> — actually blocking Copilot from surfacing a sensitive folder, or hard-restricting a site to a named group — that lever still lives in Purview, not in ShareGate’s chat window. Know which problem you’re solving before you open the conversation.</p><p><strong>PS: Ready to implement proper AI agent governance?</strong> Contact me, Ragnar Heil, for a consultation on M365 Goverance, Agent 365, SharePoint Advanced Management, Microsoft Purview (Information Protection, Data Loss Prevention Policies, DSPM for AI). Find my calendar here at our <a href="https://get.hansevision.com/de/governance"><strong>HanseVision Governance Landing Page</strong></a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=824b96288f06" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mcp-server/from-powershell-to-prompt-the-quiet-end-of-scripted-sharepoint-cleanup-824b96288f06">From PowerShell to Prompt: The Quiet End of Scripted SharePoint Governance</a> was originally published in <a href="https://medium.com/mcp-server">MCP-Server</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[5 MCP Servers I Connected to Claude, and What Actually Changed]]></title>
            <link>https://medium.com/mcp-server/5-mcp-servers-i-connected-to-claude-and-what-actually-changed-8d5114fbd76e?source=rss----3625a908dd02---4</link>
            <guid isPermaLink="false">https://medium.com/p/8d5114fbd76e</guid>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Hoe shi Lee]]></dc:creator>
            <pubDate>Tue, 21 Jul 2026 15:39:27 GMT</pubDate>
            <atom:updated>2026-07-21T15:39:26.520Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vqZvjZy4ILWM4151soPQeg.png" /></figure><p>I have been using <a href="https://modelcontextprotocol.io/">Model Context Protocol</a> servers with <a href="https://claude.ai/">Claude </a>for the past few 8 months, mostly to see which ones save real time and which ones are just extra setup for little payoff. Five stood out enough that I kept them connected. Here is what each one does, how it changed my workflow, and how you can set it up yourself.</p><p>None of these took more than 5 to 10 minutes to connect, and you can drop each one into a workflow you are probably already running. If you want to try any of these, you do not need to overhaul how you work first. Connect the server, point Claude at the task you already do by hand, and see what it hands back.</p><p>If you are still deciding which servers are worth the setup, my <a href="https://claude.ai/chat/INSERT-LINK">roundup of recommended MCP servers for building AI agents</a> covers a wider list than this one.</p><h3>1. Notion MCP</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S9hylepVCvtvqQibOx8lMw.png" /></figure><p>Connecting <a href="https://developers.notion.com/guides/mcp/overview">Notion MCP</a> meant Claude could read and update my workspace directly, so I stopped copying notes back and forth between tabs. I ask Claude to pull a page, summarize a project, or draft a new doc, and it writes straight into Notion. The setup took a few minutes and it has stayed reliable since.</p><p>If your team already lives in Notion, you can connect this one in about 5 minutes and drop it straight into your existing documentation workflow, no restructuring required.</p><p><strong>Pricing:</strong> Freemium. Free to connect, with paid Notion plans (Plus, Business, Enterprise) unlocking more workspace features.</p><h3>2. MCP360</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3P06QUDH02TmMgif3A_Bqw.png" /></figure><p><a href="https://mcp360.ai/">MCP360</a> works as the gateway that manages all my other MCP connections in one place instead of juggling separate configs for each server. Once it was set up, adding new servers took far less effort, and permissions stayed organized without extra tooling. This is the piece that made the rest of the list practical to maintain.</p><p>If you are connecting more than one or two servers, you will likely want a gateway like this in your own workflow too, rather than managing each one on its own. Setup runs about the same 5 to 10 minutes as the others on this list, and every server you add after that gets faster.</p><p>I go into more depth on how the gateway model compares to connecting servers directly in my <a href="https://claude.ai/chat/INSERT-LINK">piece on MCP server platforms for teams</a>.</p><p><strong>Pricing:</strong> Freemium.</p><h3>3. Context7</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5BLTFn3NAS8kKLOd-itoxQ.png" /></figure><p><a href="https://context7.com/">Context7</a> pulls current documentation for libraries and frameworks straight into a Claude conversation, so answers about specific APIs stop relying on outdated training data. Whenever I am working with a library that changes often, this is the server I reach for first. It cuts down on the back and forth of checking docs separately.</p><p>If you spend any part of your week checking library docs against what Claude tells you, this is worth connecting first. It slots into a coding workflow without changing how you already ask questions.</p><p><strong>Pricing:</strong> Freemium.</p><h3>4. Slack MCP</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TeY2pEKm14j-mDFopixwKA.png" /></figure><p><a href="https://mcp.slack.com/">Slack MCP</a> lets Claude read channels and draft messages without leaving the conversation. I use it mostly to summarize a busy thread before a meeting or draft a reply I can review and send myself. It has not replaced Slack, but it has cut the time I spend scrolling through unread messages.</p><p>If your mornings start with catching up on threads you missed overnight, you can hand that first pass to Claude and get straight to the ones that need a reply.</p><p><strong>Pricing:</strong> Free.</p><h3>5. Playwright MCP</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uU9txfuEXpUNHygURYBNdA.png" /></figure><p><a href="https://github.com/microsoft/playwright-mcp">Playwright MCP</a> gives Claude the ability to control a browser, click through pages, and check what actually renders. I use it for quick checks on a live site or to walk through a form before handing it to QA. It is the most technical of the five, and it is still one of the faster ones to set up.</p><p>If you regularly test forms, flows, or a live site before shipping, this one lets you offload the first pass and only step in once something actually breaks.</p><p><strong>Pricing:</strong> Free.</p><h3>Final Thoughts</h3><p>These five cover most of what I need day to day, from notes and docs to messaging and browser checks. Most of them are free to start, so testing this setup did not cost anything upfront.</p><p>MCP360 sits underneath the rest as the gateway layer, and it is the reason I have not had to rethink this setup since putting it together. Adding a sixth or seventh server from here is a matter of minutes, not a new config to maintain.</p><p>If you are starting from zero, pick the one server above that maps to the task eating the most of your week and connect that first. Add the gateway once you are past two or three servers, not before. That order kept my own setup from turning into busywork, and it is the same order I would follow if I were starting over today.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8d5114fbd76e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mcp-server/5-mcp-servers-i-connected-to-claude-and-what-actually-changed-8d5114fbd76e">5 MCP Servers I Connected to Claude, and What Actually Changed</a> was originally published in <a href="https://medium.com/mcp-server">MCP-Server</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Claude Code Plugins: Six Months In, Here’s What I Got Wrong First]]></title>
            <link>https://medium.com/mcp-server/claude-code-plugins-six-months-in-heres-what-i-got-wrong-first-396213cdd84f?source=rss----3625a908dd02---4</link>
            <guid isPermaLink="false">https://medium.com/p/396213cdd84f</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[plugins]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[mcps]]></category>
            <dc:creator><![CDATA[Jamieparker]]></dc:creator>
            <pubDate>Mon, 13 Jul 2026 14:47:58 GMT</pubDate>
            <atom:updated>2026-07-13T14:47:56.921Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Claude Code plugins connected to slash commands, MCP servers, hooks, and subagents, illustrating a modular AI development workflow." src="https://cdn-images-1.medium.com/max/1024/1*rDGyrg6XrB6XshQtWTj32w.png" /><figcaption>Claude Code Plugins</figcaption></figure><p>My Claude Code setup before plugins: a folder of handwritten markdown files, an MCP config I kept forgetting to update after switching projects, and the same slash commands copy-pasted into every repo. New machine? Forty minutes of manual reconstruction. Onboarding someone? A zip file and a README they half-read.</p><p>The plugin system shipped in public beta on October 9, 2025. I missed it for three weeks.</p><h3>What a Plugin Is (And What It Is Not)</h3><p>A Claude Code plugin is a packaging format. It bundles slash commands, subagents, hooks, MCP server connections, and language-server configs into one installable unit. One command to add it, one command to remove it. Commands from different plugins never collide because each plugin gets its own namespace — a commit skill inside commit-commands runs as /commit-commands:commit, not /commit.</p><p>Three concepts get mixed up constantly, so worth separating them once:</p><p>A <strong>skill</strong> is a SKILL.md file in your project. It shapes how Claude approaches a task and loads automatically when Claude Code reads your folder.</p><p>An <strong>MCP server</strong> is a live connection to an external tool using the Model Context Protocol. Because MCP is a portable standard, the same server works in Cursor, Windsurf, Gemini CLI, and other clients — not just Claude Code. If you want to understand why that portability matters, the <a href="https://mcp360.ai/blog/mcp-vs-apis">MCP vs APIs breakdown on MCP360</a> explains the architectural difference clearly.</p><p>A <strong>plugin</strong> is how both of the above get packaged and distributed as one unit, specific to Claude Code. The MCP server inside the plugin still speaks the same portable protocol. The plugin is just the delivery mechanism.</p><h3>The Context Cost Problem</h3><p>Every active plugin adds to your system prompt on every turn, whether you use it that session or not. A plugin bundling three subagents and twelve skills costs tokens on every message you send.</p><p>Recent Claude Code builds show a context cost estimate before you confirm an install. I missed this feature for a while, enabled six plugins in my first two weeks, and spent those two weeks wondering why responses felt heavier. Disabling four idle ones was the fix.</p><p>The /plugin menu now flags plugins you haven&#39;t touched in weeks. First time I checked it, five were flagged. I disabled all five. None of them came back to bite me.</p><p>Short list, actively used. That’s the whole strategy.</p><h3>Three Marketplaces, Very Different Trust Levels</h3><p>A marketplace is a git repo with a marketplace.json file. Three types exist:</p><p>The <strong>official marketplace</strong> (claude-plugins-official) registers itself on first launch. Start here.</p><p>The <strong>community marketplace</strong> (anthropics/claude-plugins-community) holds third-party plugins that passed automated validation. You add it yourself: /plugin marketplace add anthropics/claude-plugins-community. The screening is real but lighter than the official directory. Each plugin is pinned to a specific commit so it can&#39;t silently update.</p><p><strong>Third-party marketplaces</strong> are any git URL, local path, or hosted JSON file. Seth Hobson’s wshobson/agents is a well-known example. No centralized review. You&#39;re auditing it yourself.</p><h3>The Security Issue That Should Have Been Bigger News</h3><p>In January 2026, SentinelOne’s Prompt Security team documented an attack using a marketplace plugin from an unofficial source. The plugin’s dependency skill redirected a routine Python install to an attacker-controlled server. The library imported cleanly. The example code ran fine. Trojanized code sat in the project.</p><p>Not a hypothetical. Documented. It happened.</p><p>A plugin runs with your user permissions. It can read and write files, access environment variables, and open network connections. Installing one is closer to adding an npm dependency than enabling a browser extension.</p><p>Anthropic runs two tiers of review on its own directory. Every listed plugin clears automated screening. Plugins that pass an added human review get an “Anthropic Verified” badge. The badge matters. It does not mean guaranteed clean, and Anthropic’s own documentation doesn’t say it does.</p><p>Four things I check before installing anything outside the official directory:</p><p><strong>Does the permission request match the job?</strong> A commit formatter asking for broad network access is a mismatch. I stop there.</p><p><strong>Can I read the source?</strong> Official directory plugins link to a repo. I open it. For third-party plugins, this is not optional.</p><p><strong>Is there a Verified badge?</strong> It’s the strongest signal available inside the official directory.</p><p><strong>Is it toggled off when I’m not using it?</strong> A disabled plugin can’t run hooks or load MCP connections. That cuts both context cost and attack surface at once.</p><h3>Ten Plugins Worth Installing</h3><p><strong>commit-commands</strong> — First install on every machine. /commit stages changes and writes a message from the actual diff. /commit-push-pr extends that into a full loop: commit, push, open a PR. /clean_gone removes local branches already deleted upstream, the kind of cleanup that piles up invisibly. /plugin install commit-commands@claude-plugins-official</p><p><strong>code-review</strong> — Five parallel Sonnet agents check a pull request from different angles: CLAUDE.md compliance, bug detection, historical context, prior PR patterns, inline comments. A validation agent scores every finding for confidence. Anything below the threshold gets filtered before it reaches you. /plugin install code-review@claude-plugins-official</p><p><strong>security-guidance</strong> — A hook, not a command. Runs automatically on every file edit and checks for command injection, XSS, and unsafe patterns before the change lands. Newer Claude Code builds enable it by default, so check before installing. /plugin install security-guidance@claude-plugins-official</p><p><strong>typescript-lsp</strong> — Runs a real TypeScript language server in the background. Claude gets live type information: type errors, missing imports, mismatched signatures, at edit time rather than after a build. For TypeScript-heavy projects, this one pays off faster than anything else on this list. /plugin install typescript-lsp@claude-plugins-official</p><p><strong>context7</strong> — Fixes one specific failure: Claude recommending deprecated methods or APIs renamed after its training cutoff. It resolves a library name to a Context7 ID, pulls current documentation from the library’s source repo, and injects it into the prompt automatically. Without an API key it runs on a shared rate limit. First: /plugin marketplace add upstash/context7 Then: /plugin install context7@context7-marketplace</p><p><strong>feature-dev</strong> — A seven-phase workflow for building from a plain-language description. A code-explorer agent maps your codebase first, a code-architect agent designs the approach, a code-reviewer agent checks the result against that plan. I use this when a feature touches multiple files and I want the design phase to happen before the first line of code. /plugin install feature-dev@claude-plugins-official</p><p><strong>playwright</strong> — Microsoft’s browser automation MCP server. Gives Claude a real browser: navigate URLs, click, fill forms, handle uploads, take screenshots, run test assertions, inspect network requests and console logs. Good for end-to-end flows I’d otherwise click through manually. /plugin install playwright@claude-plugins-official</p><p><strong>figma</strong> — Reads layout, typography, color, and component data directly from a Figma frame. Code Connect maps the output to your actual codebase components. Share a Figma URL and ask Claude to implement it, or run /implement-design to translate a frame using your design system. Authenticate your Figma account after install. /plugin install figma@claude-plugins-official</p><p><strong>frontend-design</strong> — Auto-invokes on frontend work rather than requiring a command. Steers output toward deliberate typography and color decisions instead of the generic defaults AI-generated UI tends to produce. Most noticeable on greenfield work with no existing design system. /plugin install frontend-design@claude-plugins-official</p><p><strong>chrome-devtools-mcp</strong> — Connects Claude to a live Chrome browser through the Chrome DevTools Protocol. Performance-focused: traces, Core Web Vitals from the CrUX report, console messages with source-mapped stack traces, network inspection, viewport screenshots. Complements playwright rather than replacing it. First: /plugin marketplace add ChromeDevTools/chrome-devtools-mcp Then: /plugin install chrome-devtools-mcp@chrome-devtools-plugins</p><p>The full official directory is at <a href="https://claude.com/plugins">claude.com/plugins</a>. Eleven language servers (Python, Rust, Go, C/C++, Java, C#, Kotlin, Lua, PHP, Swift) and partner integrations for GitHub, GitLab, Linear, Box, Airtable, Buildkite, and others are all in there. Worth browsing before you go hunting for third-party alternatives.</p><h3>The Trap I Hit Around Plugin Eight</h3><p>I kept adding one plugin per service. By the time I had eight active, each one needed its own source audit, its own permission check, its own context budget. The plugin list had become the same fragmented mess I was trying to get away from.</p><p>The fix was switching to a gateway plugin. One MCP server connected to many tools through a single endpoint, loading each tool on demand rather than listing everything in the system prompt upfront. I reviewed one source instead of eight. The .mcp.json config at the plugin root stays simple:</p><pre>{<br>  &quot;mcpServers&quot;: {<br>    &quot;mcp360&quot;: {<br>      &quot;command&quot;: &quot;npx&quot;,<br>      &quot;args&quot;: [&quot;mcp-remote&quot;, &quot;https://connect.mcp360.ai/v1/mcp360/mcp?token=YOUR_API_KEY&quot;]<br>    }<br>  }<br>}</pre><p>New tools added to the gateway become available automatically without touching the plugin. The <a href="https://mcp360.ai/blog/mcp360-unified-ai-gateway">MCP360 unified gateway</a> is what I use for this — it covers 100+ tools through that one endpoint. Worth knowing about before you install your sixth single-purpose integration. There’s also a broader list of <a href="https://mcp360.ai/blog/essential-mcp-servers">production MCP servers worth knowing about</a> if you’re still building out what your stack connects to.</p><h3>Team Setup</h3><p>Project-scope installs are the mechanism for standardizing a shared workflow. When you install at project scope, the plugin writes into the repo’s .claude/settings.json. Every collaborator who trusts that folder gets it on next pull. One install, version-controlled, no zip files.</p><p>Two org-level settings matter if you manage this across a team:</p><p>extraKnownMarketplaces registers a company marketplace for the whole org. Teammates opening a trusted repo get prompted to install from it.</p><p>strictKnownMarketplaces locks out any marketplace source not on the approved list.</p><p>If your team runs MCP servers across multiple clients beyond Claude Code, a server manager like <a href="https://mcp360.ai/blog/introducing-mtarsier-an-open-source-mcp-server-manager">mTarsier</a> keeps configurations consistent everywhere. Plugins control scope inside Claude Code. That’s a separate problem from managing which MCP servers run in Cursor or your agent stack.</p><h3>Building One</h3><p>Three files, one afternoon.</p><p><strong>Manifest</strong> at .claude-plugin/plugin.json:</p><pre>{<br>  &quot;name&quot;: &quot;my-plugin&quot;,<br>  &quot;description&quot;: &quot;What it does&quot;,<br>  &quot;version&quot;: &quot;1.0.0&quot;<br>}</pre><p><strong>Skill</strong> at skills/my-skill/SKILL.md:</p><pre>---<br>description: Reviews code for best practices. Use when checking PRs or analyzing code quality.<br>---</pre><pre>When reviewing code, check organization, error handling, security, and test coverage.</pre><p><strong>MCP connection</strong> (optional) at .mcp.json at the plugin root. Anyone who installs the plugin gets those server connections without touching their own config.</p><p>Test without installing: claude --plugin-dir ./my-plugin. Pick up edits without restarting: /reload-plugins. Validate before sharing: claude plugin validate.</p><p>Publishing is a git push. Point someone at the URL and they can add it as a marketplace directly.</p><h3>Answers to the Questions That Come Up</h3><p><strong>Can I use Claude Code plugins in regular claude.ai?</strong> No. The plugin system is specific to Claude Code — terminal, VS Code, JetBrains, the desktop app, claude.ai/code. The main chat interface has none of this. Most confusion I’ve seen comes from this.</p><p><strong>What goes away when I uninstall?</strong> Everything bundled with the plugin: commands, hooks, subagents, MCP connections. If a plugin wrapped a gateway, that connection goes too. After uninstalling, check your installed agents and MCP servers to confirm nothing was left behind.</p><p><strong>How different is the community marketplace from the official one?</strong> Official: registered automatically, reviewed by Anthropic directly. Community: third-party, automated validation, commit-pinned so it can’t silently change, you add it yourself. Neither is a guarantee. Source review and permission checks are always on you regardless of which marketplace you pull from.</p><p><strong>Why do I keep seeing context get slower as I add plugins?</strong> Each active plugin extends your system prompt on every turn. The cost is real and cumulative. The context estimate shown before install tells you what you’re taking on. The idle plugin flag in the /plugin menu tells you what you&#39;re paying for but not using.</p><h3>Before You Post</h3><p>Start with one plugin that removes friction you’re already feeling. Use it for two weeks. If it earns its spot, keep it. Then add the next one.</p><p>Read the repository before installing anything outside the official directory. Not the description page. The code.</p><p>The full reference I kept open while setting all this up is the <a href="https://mcp360.ai/blog/claude-code-plugins-the-complete-guide-for-2026">Claude Code plugins guide on MCP360</a> — install commands, full directory breakdown, build walkthrough. Worth bookmarking if you’re going deeper than what I’ve covered here.</p><p><strong>Tags:</strong> Claude Code · Anthropic · MCP · Model Context Protocol · AI Developer Tools · Developer Productivity · Software Engineering · AI Tools 2026</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=396213cdd84f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mcp-server/claude-code-plugins-six-months-in-heres-what-i-got-wrong-first-396213cdd84f">Claude Code Plugins: Six Months In, Here’s What I Got Wrong First</a> was originally published in <a href="https://medium.com/mcp-server">MCP-Server</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Rise of MCP: Protocol Adoption in 2026 and Emerging Monetization Models]]></title>
            <link>https://medium.com/mcp-server/the-rise-of-mcp-protocol-adoption-in-2026-and-emerging-monetization-models-cb03438e985c?source=rss----3625a908dd02---4</link>
            <guid isPermaLink="false">https://medium.com/p/cb03438e985c</guid>
            <category><![CDATA[mcp-2026]]></category>
            <category><![CDATA[mcp-shopping]]></category>
            <category><![CDATA[mcp-monetization]]></category>
            <category><![CDATA[mcp-marketplace]]></category>
            <category><![CDATA[mcp-subscription]]></category>
            <dc:creator><![CDATA[Gary Weiss]]></dc:creator>
            <pubDate>Mon, 23 Feb 2026 16:47:21 GMT</pubDate>
            <atom:updated>2026-02-23T16:47:20.522Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><em>February 2026</em></blockquote><blockquote>Disclosure: the author is a founder of MCP-Hive, referenced in Part 3.</blockquote><h3>Part 1: Current State of Affairs</h3><h3>A Standard Born from Necessity</h3><p>In the summer of 2024, Anthropic’s engineers faced a challenge common across the AI industry: every model-to-tool integration required bespoke, fragile plumbing rebuilt from scratch. The solution was the <a href="https://modelcontextprotocol.io/">Model Context Protocol (MCP)</a>, an open standard through which AI models communicate with external tools and data sources. Open-sourced on November 25, 2024, it immediately attracted industry attention.</p><p>Adoption was swift. OpenAI, Google DeepMind, and Microsoft Copilot Studio added support within months, as did developer tools including Cursor, Replit, and Zed. By November 2025 the ecosystem had reached <a href="https://www.pento.ai/blog/a-year-of-mcp-2025-review">97 million monthly SDK downloads</a>. In December 2025, Anthropic donated MCP to the newly formed <a href="https://www.anthropic.com/news/donating-the-model-context-protocol-and-establishing-of-the-agentic-ai-foundation">Agentic AI Foundation (AAIF)</a> under the Linux Foundation, co-founded with Block and OpenAI and backed by AWS, Google, Microsoft, Salesforce, and Snowflake, cementing its status as a vendor-neutral industry standard.</p><figure><img alt="Arrangement of antique tools" src="https://cdn-images-1.medium.com/max/1024/0*SH_nyK8bSHqZuhQM" /><figcaption>Photo by <a href="https://unsplash.com/@toddquackenbush?utm_source=medium&amp;utm_medium=referral">Todd Quackenbush</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Three Classes of Adoption</h3><p>By early 2026, <a href="https://zuplo.com/mcp-report">more than ten thousand MCP servers</a> have been indexed across public registries. Three distinct categories have emerged:</p><ul><li><strong>Internal organizational servers</strong> — the largest category by volume, built by companies for their own agents to access proprietary systems (databases, CRMs, HR platforms). Invisible in public directories, they represent MCP’s deepest operational penetration.</li><li><strong>Vendor-built integrations</strong> — official servers published by technology companies (GitHub, Stripe, Atlassian, Salesforce) to offer AI connectivity to their respective platforms. Generally well-maintained and properly authenticated.</li><li><strong>Community general-purpose servers</strong> — open-source, volunteer-built connectors for broadly useful tasks (web search, weather data, file management). The most publicly visible, yet varied in quality, and — as Part 2 argues — in need of a sustainable funding model.</li></ul><h3>The Agentic Framework Ecosystem and Extensions</h3><p>MCP has now become the de facto tool-calling standard for major agentic AI frameworks — LangChain, LlamaIndex, Microsoft AutoGen, and CrewAI — which adopted the protocol as its momentum grew. The result is agentic stacks in which MCP serves as the connective tissue between reasoning models and the external world.</p><p>Two significant extensions arrived in early 2026, each broadening MCP’s reach. <a href="https://blog.modelcontextprotocol.io/posts/2026-01-26-mcp-apps/"><strong>MCP Apps</strong></a>, announced on January 26, 2026, breaks MCP out of its text-only interaction model: tools can now return interactive UI components — dashboards, forms, charts — that render directly inside the conversation window. Claude launched first; VS Code, Microsoft 365 Copilot, and OpenAI followed.</p><p>Also in January 2026, Google’s Sundar Pichai unveiled the <a href="https://developers.googleblog.com/under-the-hood-universal-commerce-protocol-ucp/"><strong>Universal Commerce Protocol</strong> (UCP)</a> at NRF, with Shopify as its most prominent partner alongside Walmart, Target, and major payment networks. UCP is not an MCP sub-protocol: it is a Google-led commerce standard supporting multiple transports, one of which is MCP. UCP defines the commerce primitives — discovery, negotiation, checkout — while MCP is one channel through which those primitives travel. The monetization implications are explored in Part 3.</p><figure><img alt="Arrangement of antique wood-cutting tools, hanging on a wall" src="https://cdn-images-1.medium.com/max/1024/0*TIUyErBNMbtE43W5" /><figcaption>Photo by <a href="https://unsplash.com/@meanduck?utm_source=medium&amp;utm_medium=referral">Minh Đức</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Part 2: Existing Challenges</h3><h3>The Quality Stratification Problem</h3><p>The impressive server implementation counts that headline MCP’s growth conceal a structural tension that anyone navigating the ecosystem quickly encounters. Adoption has been deepest in developer and tech-enablement tooling; penetration into regulated industries and general-consumer data remains limited. The more important observation is the quality hierarchy that has solidified between the ecosystem’s two visible layers.</p><ul><li><strong>Class A servers</strong> — those built by organizations with a direct commercial stake in the integration, such as AWS, GitHub, and Stripe — are well-maintained, properly authenticated, and supported with predictable update cycles.</li><li><strong>Class B servers</strong> (the community-built tier) present a materially different picture. <a href="https://astrix.security/learn/blog/state-of-mcp-server-security-2025/">Research published by Astrix Security in 2025</a> found that 53 percent of community servers rely on static API keys or Personal Access Tokens, credentials that are long-lived and rarely rotated. Over 1,800 servers were found on the public internet without any authentication whatsoever. In general, the absence of a business model has led to basic implementations and this is reflected in the resulting quality.</li></ul><p>The risks this creates are not hypothetical. In September 2025, an unofficial Postmark MCP server with fifteen hundred weekly downloads was covertly modified to silently add a blind carbon copy field to its email-sending function, routing a copy of every outbound message to an attacker’s address. Users had no indication that anything had changed. The incident illustrates a structural vulnerability: the trust that developers and AI agents place in tool registries and documentation is not yet matched by the verification mechanisms in place to justify it. The conclusion is that the ecosystem currently sustains two parallel experiences — a reliable, well-funded tier of vendor-backed servers, and a valuable but fragile commons of community work.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*hsZlXIGWmy0mEDSA" /><figcaption>Photo by <a href="https://unsplash.com/@nate_dumlao?utm_source=medium&amp;utm_medium=referral">Nathan Dumlao</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Part 3: Emerging Monetization Opportunities</h3><p>The free and community model that powered MCP’s rapid initial growth lacks a sustainable foundation for the ecosystem’s next phase. High-quality, broad-purpose MCP server development — the kind that could give AI agents reliable access to premium data sources, original proprietary content, and expert systems — requires ongoing investment in security, reliability, and maintenance. Let’s explore three monetization approaches that have emerged, each representing a different theory of how that gap might be closed.</p><h3>Approach 1: Bring-Your-Own-API-Key</h3><p>The current baseline is the Bring-Your-Own-API-Key model, sometimes referred to as BYOK. Users authenticate against an underlying service using credentials they already hold, and the MCP server acts as a thin adapter layer. The <a href="https://github.com/massive-com/mcp_massive">Massive.com MCP server</a> for financial and market data is a representative example: the server itself is freely available, but meaningful access requires a paid Massive.com API subscription. The model encounters a high-friction set-up, as the client must first purchase a subscription. There is no ad-hoc access.</p><p>It is also illustrative of the quality-gap problem identified in Part 2. The most widely circulated <a href="https://github.com/TimLukaHorstmann/mcp-weather">AccuWeather MCP server</a> is community-built — not an official AccuWeather product — yet it appears in registries without that distinction being obvious to most users. Someone with an AccuWeather API key gets weather data; someone without one hits a dead end. BYOK works for technically sophisticated users who already have API access to the underlying services, but it does not widen the ecosystem’s reach, does not generate revenue for server authors, and creates no incentive to invest in security or reliability beyond the minimum needed for personal use.</p><h3>Approach 2: Pay-Per-Use Aggregators and MCP Gateways</h3><p>A structurally more interesting model has emerged in the form of centralized platforms that meter agent traffic and route billing between server authors and consumers.</p><ul><li><strong>MCP-dedicated newcomers</strong> like <a href="https://mcp-hive.com/">MCP-Hive</a> combine a curated server directory with a gateway layer, opening access to commercial-grade servers through a single endpoint. This approach implements discovery, whereby the agentic layer can explore different paid MCP Servers. In the case of MCP-Hive, the marketplace implements billing, and creates a zero-friction solution for both publishers and consumers simultaneously. This is a meaningful advantage given that AI agents, unlike human users, can trigger hundreds of tool invocations per session, using only what they really need for the task at hand.</li><li><strong>Established API gateway companies</strong> have layered MCP support onto existing infrastructure. <a href="https://konghq.com/solutions/mcp-production-and-consumption">Kong</a> has extended its API Gateway to expose MCP servers as managed endpoints, applying its policy enforcement, authentication, and observability tooling to agentic traffic. <a href="https://www.moesif.com/blog/api-strategy/model-context-protocol/Monetizing-MCP-Model-Context-Protocol-Servers-With-Moesif/">Moesif</a>, an API analytics and monetization platform, supports per-call billing, hybrid models combining base subscriptions with usage overages, and outcome-based pricing — charging only when an invocation returns a successful result.</li></ul><p>These gateway models represent a plausible near-term path to sustainable monetization for high-quality community servers. In order to be successful, these approaches need to build trust by surfacing only high-quality MCP solutions, and open access to a broad space of tools.</p><h3>Approach 3: Agentic Commerce via the Universal Commerce Protocol</h3><p>In parallel, a shift is emerging at a different level of abstraction entirely: shopping. The <a href="https://developers.googleblog.com/under-the-hood-universal-commerce-protocol-ucp/">Universal Commerce Protocol</a> is designed to enable AI agents to discover, compare, negotiate, and complete transactions with merchants without requiring the user to engage with a checkout flow. Under UCP, a user’s AI agent browses merchant catalogs, compares offerings across sellers, applies pre-authorized preferences, and completes a purchase — <em>autonomously</em>. This suggests an underlying shift in the end-user’s shopping journey, delegating part of the decision-making to the AI Agent. Merchant protections are built into the protocol design: merchants remain the Merchant of Record, retain their customer relationships, and define the parameters within which agents may operate.</p><p>Because MCP is one of UCP’s supported transports, this development is directly relevant to the protocol’s economic future. Any MCP server that surfaces product, service, or data offerings becomes a potential node in a commerce graph that AI agents can traverse and transact within autonomously. Together with MCP Apps, this introduces a new paradigm for AI-enhanced shopping.</p><h3>Outlook</h3><p>As the MCP ecosystem evolves, at a fast pace, we look forward to an interesting 2026. It is clear that the number of transactions executing over Agentic AI will grow. It is less clear what this will look like. The spaces to watch out for will be ad-hoc paid access to original content and expert data, using platforms such as MCP-Hive; and the evolution of end-user shopping patterns via early adopters of MCP Apps and UCP.</p><figure><img alt="Toy Robot holding a credit card" src="https://cdn-images-1.medium.com/max/1024/1*WM5RbuJZAhpVU_HyM3CzEQ.png" /></figure><h3>Sources</h3><p>1 <a href="https://www.anthropic.com/news/donating-the-model-context-protocol-and-establishing-of-the-agentic-ai-foundation">Anthropic: Donating MCP to the AAIF</a> Primary source: origin story, timeline, and governance transition to Linux Foundation</p><p>2 <a href="https://www.linuxfoundation.org/press/linux-foundation-announces-the-formation-of-the-agentic-ai-foundation">Linux Foundation: AAIF Press Release</a> Authoritative member roster for AAIF Platinum and Gold tiers</p><p>3 <a href="https://www.pento.ai/blog/a-year-of-mcp-2025-review">Pento: A Year of MCP</a>Best single-document timeline of milestones and growth metrics, Nov 2024–Nov 2025</p><p>4 <a href="https://techcrunch.com/2025/12/09/openai-anthropic-and-block-join-new-linux-foundation-effort-to-standardize-the-ai-agent-era/">TechCrunch: OpenAI, Anthropic &amp; Block join Linux Foundation</a> Reliable mainstream coverage of AAIF formation with industry context</p><p>5 <a href="https://zuplo.com/mcp-report">Zuplo: State of MCP — Adoption, Security &amp; Production Readiness</a> Industry research report: quantitative adoption data, security findings, enterprise readiness</p><p>6 <a href="https://www.thoughtworks.com/en-us/insights/blog/generative-ai/model-context-protocol-mcp-impact-2025">Thoughtworks: The Model Context Protocol’s Impact on 2025</a> Practitioner analysis from a leading consultancy on MCP’s integration impact</p><p>7 <a href="https://blog.modelcontextprotocol.io/posts/2026-01-26-mcp-apps/">MCP Official Blog: MCP Apps (Jan 26 2026)</a> Primary source for MCP Apps specification and launch details</p><p>8 <a href="https://www.theregister.com/2026/01/26/claude_mcp_apps_arrives/">The Register: Claude supports MCP Apps</a> Reliable independent coverage of the MCP Apps / MCP-UI launch</p><p>9 <a href="https://shopify.engineering/mcp-ui-breaking-the-text-wall">Shopify Engineering: MCP-UI</a> Technical background on MCP-UI origins and interactive commerce use cases</p><p>10 <a href="https://developers.googleblog.com/under-the-hood-universal-commerce-protocol-ucp/">Google Developers Blog: Under the Hood — UCP</a> Authoritative source on UCP architecture, transport options, and merchant protections</p><p>11 <a href="https://www.cdata.com/blog/2026-year-enterprise-ready-mcp-adoption">CData: 2026 — The Year for Enterprise-Ready MCP</a> Enterprise perspective on production deployment patterns for MCP in 2026</p><p>12 <a href="https://astrix.security/learn/blog/state-of-mcp-server-security-2025/">Astrix Security: State of MCP Server Security 2025</a> Research data on authentication gaps, static key prevalence, and real-world incidents</p><p>13 <a href="https://arxiv.org/html/2511.20920v1">arXiv: Securing the Model Context Protocol</a> Academic analysis of threat categories, attack vectors, and governance frameworks</p><p>14 <a href="https://www.moesif.com/blog/api-strategy/model-context-protocol/Monetizing-MCP-Model-Context-Protocol-Servers-With-Moesif/">Moesif: Monetizing MCP Servers</a> Per-call billing, hybrid models, and outcome-based pricing for MCP server operators</p><p>15 <a href="https://konghq.com/solutions/mcp-production-and-consumption">Kong: MCP Production and Consumption</a> Enterprise API gateway approach to MCP traffic management and monetization</p><p>16 <a href="https://ritza.co/articles/gen-articles/mcp-server-monetization-the-emerging-commercial-landscape/">Ritza: MCP Server Monetization — The Emerging Commercial Landscape</a> Survey of BYOK, gateway, and marketplace monetization models</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cb03438e985c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mcp-server/the-rise-of-mcp-protocol-adoption-in-2026-and-emerging-monetization-models-cb03438e985c">The Rise of MCP: Protocol Adoption in 2026 and Emerging Monetization Models</a> was originally published in <a href="https://medium.com/mcp-server">MCP-Server</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building an MCP Server for Your Kafka Cluster]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/mcp-server/building-an-mcp-server-for-your-kafka-cluster-16d7c1655409?source=rss----3625a908dd02---4"><img src="https://cdn-images-1.medium.com/max/1024/1*xOpMWzM2tg0ttAoTp6wfSA@2x.jpeg" width="1024"></a></p><p class="medium-feed-snippet">A step&#x2011;by&#x2011;step guide to using FastMCP and the MCP protocol to expose Kafka operations (topic management, produce/consume, troubleshooting)</p><p class="medium-feed-link"><a href="https://medium.com/mcp-server/building-an-mcp-server-for-your-kafka-cluster-16d7c1655409?source=rss----3625a908dd02---4">Continue reading on MCP-Server »</a></p></div>]]></description>
            <link>https://medium.com/mcp-server/building-an-mcp-server-for-your-kafka-cluster-16d7c1655409?source=rss----3625a908dd02---4</link>
            <guid isPermaLink="false">https://medium.com/p/16d7c1655409</guid>
            <category><![CDATA[kafka]]></category>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[claude]]></category>
            <dc:creator><![CDATA[Joel Hanson]]></dc:creator>
            <pubDate>Sun, 25 Jan 2026 12:58:01 GMT</pubDate>
            <atom:updated>2026-01-25T12:58:00.485Z</atom:updated>
        </item>
    </channel>
</rss>