MCP server implementations
Hands-on server builds, deployments, testing, SDKs, transports, and language/framework-specific implementation walkthroughs.
34%
Best tweets about Model Context Protocol
50 Best Tweets About Model Context Protocol (2026)
Read the best tweets about Model Context Protocol, including MCP servers, clients, tools, security, integrations, and implementation lessons. Updated weekly.
Technical MCP implementations and ecosystem analysis, with bare and unrelated uses of the acronym excluded.
- Creators
- 44
- Updated
Original Xholic analysis
What 50 top Model Context Protocol posts reveal
MCP discussion emphasizes practical server builds and integrations, alongside recurring production concerns around tool scope, schema design, scoped access, testing, and untrusted server metadata. A central debate is whether large, preloaded tool catalogs should give way to on-demand discovery, code mode, CLI-style interfaces, and tighter governance.
- Dominant tone
- Positive
- Median score
- 7.89
- Leading format
- Announcement
- Recent posts
- 50%
60% of posts
All-time engagement
42% of posts
Published in 90 days
Conversation map
The themes creators return to
Integrations and applied use cases
MCP connections to platforms, developer tools, business systems, data sources, creative software, and agent workflows.
30%
Tool design and context scaling
Tool-schema ergonomics, tool-count limits, context bloat, progressive discovery, filtering, aggregation, code mode, and CLI alternatives.
30%
Security, auth, and governance
OAuth, enterprise authorization, permissions, least privilege, auditing, credential handling, tool poisoning, prompt injection, and cross-server risks.
28%
Production reliability and operations
Server testing, state management, result handling, actionable errors, deployment hardening, monitoring, and operational patterns for production agents.
22%
Architecture and protocol fundamentals
Explanations of MCP hosts, clients, servers, tools, resources, prompts, JSON-RPC, and distinctions from REST APIs and function calling.
16%
Ecosystem adoption and specification
Protocol releases, client support, official servers, ecosystem growth, educational resources, and analysis of MCP as a platform standard.
16%
Agent architecture, skills, and runtimes
How MCP combines with skills, CLIs, orchestration, memory, RAG, long-running agent runtimes, and AI-native application layers.
14%
Tone and stance
Sentiment Positive leads
Author posture Supportive leads
Performance benchmark
- Median likes
- 22
- Median reposts
- 3
- Median replies
- 4
- Median views
- 2K
Posts with media make up 64% of this collection. Their median all-time score is 13.8, compared with 4.24 for text-only posts.
Format mix
- Announcement 42% · score 18.2
- Opinion 26% · score 5.07
- Tutorial 24% · score 7.89
- Case Study 4% · score 6.51
Consensus and debate
Where creators agree, and where they do not
Shared view
MCP is framed as an interoperability layer
Multiple explainers describe MCP as a standard interface between agent clients and external capabilities, distinct from REST APIs and function calling rather than a replacement for either.
Shared view
Integrations make the value tangible
Examples connect agents to X, bidirectional Figma workflows, and Xcode’s simulator, illustrating applied developer and agent workflows.
Shared view
Production design favors constrained tools
Several posts argue that human-readable parameters, precise descriptions, filtering, and smaller exposed tool sets can make tool selection easier for agents.
Shared view
Security is a server and client concern
The evidence highlights OAuth and allowlists, enterprise authorization and auditing, and risks from untrusted tool descriptions. It supports treating connected servers and their metadata as security-relevant inputs.
Open debate
MCP catalogs versus CLI or code mode
Critics argue that fully loaded tool schemas impose context costs and favor CLIs or code execution; other posts present on-demand loading and code mode as ways to retain MCP while reducing that overhead.
Open debate
Protocol utility versus indiscriminate wrapping
MCP is presented as connective infrastructure, while critics caution that wrapping every API—or placing MCP over a weak legacy API—does not itself improve the underlying system.
Open debate
Broad intelligence server versus tool budget
One server advertises 113 tools across 30+ domains, while other posts describe large tool inventories as a context and tool-selection challenge and advocate scoped exposure.
What performs
Patterns behind standout posts
Media posts outperformed the text-only median
Deterministic analytics report media on 64% of posts, with a 13.84 median all-time score for media posts versus 4.24 for text-only posts. The evidence includes integration posts with visual demonstrations.
The largest listed outliers span implementation, integration, and critique
The three highest listed outliers are an XMCP/OpenClaw setup (1,718.91), Figma’s bidirectional MCP announcement (566.41), and a CLI-versus-MCP opinion (382.26).
One MCP-and-Skills explainer was also an outlier
An explainer distinguishing MCP from skills is listed among the score outliers, indicating strong attention for at least one architecture-oriented educational post.
Conversation skewed supportive and recent
Deterministic analytics classify 62% of posts as supportive and 60% as positive; 25 of 50 posts were published within 90 days. The supplied evidence also includes substantial cautionary and critical discussion of tool scale and security.
Statistical standouts
- View standout post 1 Score 1718.9 · 217.86× median
- View standout post 2 Score 566.4 · 71.79× median
- View standout post 3 Score 382.3 · 48.45× median
- View standout post 4 Score 206.5 · 26.18× median
- View standout post 5 Score 203.6 · 25.8× median
Creator landscape
Who shapes this conversation
The five most represented creators account for 20% of the selected posts.
-
1. Moe
@katibmoe
2 posts
-
2. Vishwanath Patil
@patilvishi
2 posts
-
3. Paul Iusztin
@pauliusztin_
2 posts
-
4. Sagar Batchu
@sagar_batchu
2 posts
-
5. DEV Community
@ThePracticalDev
2 posts
-
6. Tristan Rhodes
@tristanbob
2 posts
Reach came from a fragmented creator base
The dataset contains 44 creators for 50 posts, while the top-five placement share is 20%, indicating that no small group dominates the supplied conversation.
Repeat contributors cover distinct practical angles
Among repeat contributors, Paul Iusztin posted on agent architecture and critique; Sagar Batchu posted on tool filtering and MCP security; and Vishwanath Patil posted protocol-fundamentals explainers.
Tutorial evidence pairs implementation with operations
Hands-on posts cover OAuth setup and allowlists, MCP Inspector testing, and a deployment path from local stdio to remote HTTP, connecting implementation work to operational practice.
Since the previous snapshot
What changed since Aug 20, 2026
- 80% of the selected posts remained.
- The creator count changed by +2.
- The leading sentiment remained stable.
How this analysis was made
Themes, sentiment, stance, and post format are classified per tweet. All counts, shares, medians, creator concentration, freshness, and performance comparisons are then calculated directly from the published snapshot.
Xholic's all-time score compares engagement while accounting for reach, post age, and creator consistency. It is used for relative comparisons within this collection.
This report analyzes the exact 50-post snapshot shown below. AI identifies editorial categories and drafts explanations; all statistics are calculated from the snapshot, and every narrative claim is checked against cited posts before publication.
Best Model Context Protocol tweets
Top Model Context Protocol tweets from 44 creators
Ranked 01–50
- 01
@jonoringer ·
This is huge : @X released an MCP server today.. How to Connect X to your 🦞 : **Step 1: Run the XMCP Server** git clone https://t.co/28snn6oaEa cd xmcp cp env.example .env Edit the .env file with your X OAuth consumer key and secret. Set the callback URL to http://127.0.0.1:8976/oauth/callback in your X Developer app. For safety, add an allowlist such as: X_API_TOOL_ALLOWLIST=searchPostsRecent,createPosts,getUsersMe,getPostsById,likePost,repostPost Then run: python -m venv .venv && source .venv/bin/activate pip install -r requirements.txt python https://t.co/yO2ogIBpks The server will be available at http://127.0.0.1:8000/mcp. Complete the OAuth flow on first run and keep this process active. **Step 2: Add XMCP in @OpenClaw** Use the following command: openclaw mcp set x '{ "url": "http://127.0.0.1:8000/mcp" }' Verify with: openclaw mcp list openclaw mcp show x **Step 3: Test the Integration** Restart the OpenClaw agent or reload MCP configuration if required. Test by sending these prompts to OpenClaw in your chat app: - Search recent posts about MCP on X and summarize the top trends - Draft and post this thread on X - Get my X profile information - Like the latest post from @xdevplatform OpenClaw will use the XMCP tools automatically when relevant. **Key Benefits** - OpenClaw provides persistent memory and works across multiple messaging platforms. - XMCP delivers standardized access to X API functionality. - Combined, they enable an agent that can research trends, post content, engage with posts, and report results within your existing chat workflows. **Safety and Configuration Notes** Start with a minimal tool allowlist in the XMCP .env file. Expand gradually after testing. The allowlist can be updated and requires restarting the XMCP server. Monitor logs in both the XMCP server and OpenClaw for troubleshooting. X actions performed by the agent are public. XMCP repository: https://t.co/fIxYHLI33T OpenClaw MCP documentation: https://t.co/15Rod9Q4QG
- 02
@mariorod1 ·
Design → code → canvas → feedback → repeat. The @figma MCP server is now bidirectional. @GitHub Copilot users can pull design context into code and push working UI back to the Figma canvas, all from @code . No handoffs or context switching. Just flow. https://t.co/FbDcp7kboG
Watch video
- 03
@EXM7777 ·
CLI > MCP every MCP server you connect to your agent loads ALL its tool definitions on EVERY turn you're literally burning tokens for nothing, money you're paying that never touches your actual task there are a few tools that fix this, one i tried recently is mcp2cli it converts your MCP servers to simple commands that the agent calls only when needed apparently is saves 96-99% on tokens... definitely worth a try
- 04
@betomoedano ·
Xcode 27 ships with the xcode-tools MCP server which allows your agent to interact with the simulator. This helps agents validate that the feature actually works (video is at 4x speed)
Watch video
- 05
@_avichawla ·
MCP & Skills for AI agents, clearly explained! Devs treat MCP and Skills like they're the same thing. They're not. Conflating them is one of the most common mistakes I see when people start building AI agents seriously. So let's break both down from scratch. Before MCP existed, connecting an AI model to an external tool meant writing custom integration code every single time. For instance, 10 models and 100 tools led to 1,000 unique connectors to build and maintain. MCP fixed this with a shared communication standard. Tools became a part of a “server” that exposed its capabilities. Every AI agent became a “client” that knew how to ask. They talked through structured JSON messages over a clean, well-defined interface. For instance, one could build a GitHub MCP server once, and it worked with Claude, ChatGPT, Cursor, or any other agent that spoke MCP. That’s the core value: write the integration once, use it everywhere. MCP solved the connection problem. But it did not solve the usage problem. This means you can hand an agent 50 perfectly wired MCP tools, and it can still underperform if it doesn’t know when to call which tool, in what order, and with what context. That’s the gap Skill intends to fill. A Skill is a portable bundle of procedural knowledge. Think of a SKILL(.)md file that tells an agent not just “here are your tools” but “here’s how to use them for this specific task.” - A writing skill could bundle tone guidelines and output templates. - A code review skill can bundle patterns to check and rules to follow. MCP gives the agent a hand. Skills give it muscle memory. Together, they form the full capability stack for a production AI agent: - MCP handles tool connectivity (the wiring layer) - Skills handle task execution (the knowledge layer) - The agent orchestrates both using its context and reasoning This is why advanced agent setups increasingly ship both: MCP servers for integrations and SKILL(.)md files for domain expertise. ____ Find me → @_avichawla Every day, I share tutorials and insights on DS, ML, LLMs, and RAGs.
Watch video
- 06
@arpit_bhayani ·
Fun fact: swapping UUIDs for plain integers in your MCP tool parameters cuts agent errors. When you compare UUID-based tool parameters against integer alternatives, you get several errors, and the reason is simple ... A UUID like a3f9c1e2-88b4-4d1e-9c77-... is not something the model can reason about. So, when the model needs to fill in that parameter, it is not recalling a value; it is pattern matching against what a UUID looks like. That produces a plausible-looking string that does not exist in your system. This is the core mismatch between how APIs and MCP tools get consumed. REST APIs are built for a client that already has the ID, fetched a moment ago from a database query. Even MCP is called by a model that is generating the parameter value from context, and context is made of 'words'. The fix is simple - never let the model see the raw UUID in the first place. Resolve it internally (if possible). If a tool needs to reference an entity, expose a human-readable name (even a var name works) or a simple index, and translate that back to the UUID on your side. This is worth remembering the next time you are about to pass your database's primary key straight through to a tool schema. Hope this helps.
- 07
- 08
@chadwahl ·
Because I get asked a lot Ontology-MCP (O-MCP): I want dynamic interactions at runtime with my favorite MCP client agents/frameworks. Think runtime. Palantir-MCP (P-MCP): I want to build pipelines, objects, generally do anything builders do in the platform. Think development. Ontology SDK (OSDK): I am building apps/integrations backed by the Ontology. Think design time. data, logic, action
- 09
@pauliusztin_ ·
There is a new way of building software powered by AI. Here is the architecture: Most teams are building AI applications by taking existing frontend/backend architectures and stitching agents and MCP servers into the backend. Which makes sense. Every new paradigm starts by adapting the old one. But as David Soria Parra (@AnthropicAI, co-creator of MCP) put it: "Connectivity is not one thing. The best agents use all of it - skills, CLI, MCP - together." This idea changed how I think about agent architecture... Browsers remain the primary interface. But we're moving toward a world where a single chat interface can render whatever the agent returns. The browser was built to navigate websites. AI-native interfaces are being built to generate them on demand. The architecture I see emerging across serious AI applications looks like this: 1/ Presentation The thin renderer. Today, this means: TUI (Claude Code) IDE extensions (Cursor, VS Code) Web applications Desktop applications (ChatGPT, Gemini) With MCP Apps, clients can render server-shipped UIs directly from the harness. The same MCP App can run across Claude, ChatGPT, and Cursor without rewriting the UI. 2/ Harness + Runtime The brain of the system. This is where: The LLM ↔ tool loop lives Memory lives • Permissions live Orchestration lives Agents are becoming long-running systems rather than single inference calls. Which means they need: Durable execution Retries Checkpoints Human approvals Observability This is why I increasingly think of tools like @PrefectIO as part of the runtime itself. 3/ Connectivity The right tool for the right job. Skills → reusable user domain knowledge CLIs → local host capabilities MCP Clients → auth, resources, tasks, and UI Modern agents use all three. Single-mechanism agents underperform. 4/ MCP Servers Where business logic and private data live. A modern MCP server ships: Tools Resources Prompts Skills MCP Apps Tasks + elicitation In Python, @fastmcp (by @PrefectIO) has effectively become the practical default. Even David Soria Parra said: "It’s just way better than our Python SDK that we shipped." The MCP ecosystem recently crossed 110M monthly downloads. React took roughly twice as long to get there. This is what "full connectivity" looks like. Four layers. Each independently decomposable. MCP acts as the connective tissue between them. P.S. Do you think browsers become obsolete once chat interfaces can render any application on demand?
- 10
@IntuitMachine ·
What if the reason your LLM agent feels "dumb" has nothing to do with the model—and everything to do with how you structured your MCP server? Here's what 15 production deployments teaches us about why agents succeed or fail. 🧵 2/ We keep hitting the same wall: an agent that was brilliant with 5 tools would completely fall apart at 15. Not slightly worse. Completely unusable. Same model. Same prompts. The only difference? How many tools we exposed. 3/ Turns out LLMs select tools by reading descriptions, not by browsing schemas like a human engineer would. That simple fact changes everything about how you should design an MCP server. 4/ Researchers analyzed 15 independently built MCP servers—5 from production voice AI deployments, 10 from the public registry. Five recurring patterns emerged. Each addresses a different way the LLM-client constraint breaks naive designs. 5/ Pattern 1: Resource Gateway Expose backend data as stable URIs with sanitization layers. Why it matters: user-generated content like "Ignore previous instructions…" will be processed as instruction, not data. Gateway pattern puts sanitization in one place. 6/ Pattern 2: Tool Orchestrator Collapse multi-system workflows into single composite tools. The LLM sees "create_and_notify_ticket" instead of juggling 3 separate APIs. Accuracy jumps. But there's a catch… 7/ Pattern 3: Stateful Session Server Manage conversational state server-side behind an opaque session ID. The killer feature: multi-turn "open file → edit → save" workflows become natural. The hidden trap: memory leaks if you don't reap sessions. We learned this the hard way. 8/ Pattern 4: Proxy Aggregator (the scoped variant) Route 50+ upstream MCP servers behind one endpoint but only expose the subset relevant to the current task. Static merging makes the problem worse. Scoped filtering is the only escape hatch. 9/ Pattern 5: Domain-Specific Adapter Wrap hostile APIs with human-readable descriptions, fuzzy input normalization, and plain-English errors. Example: accept "next Tuesday" instead of ISO-8601. The LLM succeeds; your API doesn't change. [The Actionable Bridge: Making It Real] 10/ Here's the part that surprised us most: Tool selection accuracy collapses between 10 and 15 tools for Haiku-class models. At 20 tools, Sonnet 4 drops below 90%. At 30, both models are guessing. [mini chart or screenshot of Fig. 2] 11/ So the tool-count budget is now a first-class architectural constraint. If you're building an MCP server that exposes more than ~12 tools, you must use the scoped Proxy Aggregator pattern or your agent will fail in ways that feel random but are actually structural. 12/ Quick audit: How many of your MCP tools have vague or missing descriptions? We found servers with names like "send_message" and no description. The LLM has no idea when to use it. Fix: write descriptions like you're explaining to someone who's never seen it before. 13/ These aren't MCP-specific hacks. They're classical software patterns—Facade, Adapter, Proxy—applied through the lens of a client that selects operations by reading descriptions instead of consulting docs. The delta is small. The implications are huge. 14/ Three leverage points if you take nothing else: Treat tool descriptions as load-bearing code (review them like schemas) Use scoped aggregation, not static merging Explicit session hygiene or you will leak state 15/ One more thing: The highest-leverage architectural decision is often removing a tool, not adding one. If your agent feels overwhelmed, the fix isn't a better prompt. It's a smaller, clearer tool surface. Less is more. Literally.
- 11
@DivyanshT91162 ·
What if you had access to a global intelligence platform... for free? This open-source project turns any AI agent into a real-time intelligence analyst. Phoenix Intelligence Dashboard is an MCP server with 113 tools across 30+ intelligence domains. It can monitor: • Financial markets & macro signals • Military flights & naval activity • Global conflicts & unrest • Cyber threats & CISA alerts • Earthquakes, wildfires & disasters • Shipping, aviation & infrastructure • SEC filings & company intelligence • AI papers & GitHub trends • Elections, sanctions & prediction markets • Space weather & disease outbreaks The best part? It continuously builds a searchable intelligence database using Qdrant. So instead of querying dozens of APIs, you can simply ask: → "Military activity near the Taiwan Strait" → "Cyber threats targeting healthcare" → "Economic indicators suggesting recession" It searches across accumulated historical intelligence and returns relevant results in seconds. Under the hood: • 113 MCP tools • 30+ intelligence domains • 43+ public data sources • Live operations dashboard • Interactive world map • Semantic vector search • PDF/HTML intelligence reports 100% open source. MIT licensed. Repo👇
- 12
@bibryam ·
Zero-touch OAuth for MCP https://t.co/A3eXRNIiTc TLDR: Standard MCP auth is too high-friction in enterprise: users authorize every server, security can’t centrally enforce policy/audit, and account mixing is easy. Enterprise-Managed Authorization makes the IdP the control plane: admins define group/role/conditional access once, and SSO exchanges an IdP-issued Identity Assertion JWT (ID-JAG) for MCP server tokens without per-server consent screens.
- 13
@Aurimas_Gr ·
Integrating 𝗔𝗴𝗲𝗻𝘁𝗶𝗰 𝗥𝗔𝗚 Systems via 𝗠𝗖𝗣 👇 If you are building RAG systems and packing many data sources for retrieval, most likely there is some agency present at least at the data source selection for retrieval stage. This is how MCP enriches the evolution of your Agentic RAG systems in such case (𝘱𝘰𝘪𝘯𝘵 2.): 𝟭. Analysis of the user query: we pass the original user query to a LLM based Agent for analysis. This is where: ➡️ The original query can be rewritten, sometimes multiple times to create either a single or multiple queries to be passed down the pipeline. ➡️ The agent decides if additional data sources are required to answer the query. 𝟮. If additional data is required, the Retrieval step is triggered. We could tap into variety of data types, few examples: ➡️ Real time user data. ➡️ Internal documents that a user might be interested in. ➡️ Data available on the web. ➡️ … 𝗧𝗵𝗶𝘀 𝗶𝘀 𝘄𝗵𝗲𝗿𝗲 𝗠𝗖𝗣 𝗰𝗼𝗺𝗲𝘀 𝗶𝗻: ✅ Each data domain can manage their own MCP Servers. Exposing specific rules of how the data should be used. ✅ Security and compliance can be ensured on the Servel level for each domain. ✅ New data domains can be easily added to the MCP server pool in a standardised way with no Agent rewrite needed enabling decoupled evolution of the system in terms of 𝗣𝗿𝗼𝗰𝗲𝗱𝘂𝗿𝗮𝗹, 𝗘𝗽𝗶𝘀𝗼𝗱𝗶𝗰 𝗮𝗻𝗱 𝗦𝗲𝗺𝗮𝗻𝘁𝗶𝗰 𝗠𝗲𝗺𝗼𝗿𝘆. ✅ Platform builders can expose their data in a standardised way to external consumers. Enabling easy access to data on the web. ✅ AI Engineers can continue to focus on the topology of the Agent. 𝟯. Retrieved data is consolidated and Reranked by a more powerful model compared to regular embedder. Data points are significantly narrowed down. 𝟰. If there is no need for additional data, we try to compose the answer (or multiple answers or a set of actions) straight via an LLM. 𝟱. The answer gets analyzed, summarized and evaluated for correctness and relevance: ➡️ If the Agent decides that the answer is good enough, it gets returned to the user. ➡️ If the Agent decides that the answer needs improvement, we try to rewrite the user query and repeat the generation loop. Are you using MCP in your Agentic RAG systems? Let me know about your experience in the comment section 👇
- 14
@jlowin ·
Since I heard about MCP Apps, my favorite use case has been uploading files to the MCP server. Previously, your only real alternative was to use your LLM as the world's slowest, most expensive copy/paste. Now... just drag and drop. Coming next week to any FastMCP server.
Watch video
- 15
@smratitiwa86867 ·
Everyone is talking about MCP. Very few can explain how it actually works. Most developers: → Install an MCP server → Connect it to Claude or ChatGPT → See it working But ask what happens behind the scenes... Silence. Here's MCP explained in plain English 👇 ⚡ What is MCP? MCP (Model Context Protocol) is an open standard that lets AI models connect to tools, databases, APIs, and applications through a single protocol. Think of it as: "USB-C for AI" Instead of building custom integrations for every model and every tool, MCP creates one universal language. Before MCP: N Models × M Tools After MCP: N + M A massive simplification. ⚡ The Architecture 3 Core Components: • Host → The AI application (Claude Desktop, IDEs, etc.) • Client → Communicates with MCP servers • Server → Exposes tools and capabilities Everything runs on JSON-RPC 2.0. Simple. Standardized. Extensible. ⚡ The 3 Building Blocks 🛠 Tools AI decides when to use them. 📄 Resources Applications provide context. 📝 Prompts Users trigger predefined workflows. ⚡ The Hidden Costs The demos look magical. Reality is more complicated: • Tool schemas get sent repeatedly • More tools = larger context windows • Token costs increase fast • OAuth and secret management become harder • Schema drift can silently break agents • Tool sprawl becomes the new microservice sprawl ⚡ The Biggest Mistake Treating MCP like a framework. It's not. MCP is a protocol. The right mental model isn't LangChain. It's HTTP. Boring. Foundational. And quietly becoming the standard layer for AI applications. Bookmark this for the next time someone asks: "How does MCP actually work?"
- 16
@socialwithaayan ·
🚨 BREAKING: AI coding agents can finally understand your entire codebase without exploding your token count. Zilliz just dropped Claude Context an open-source MCP server that makes large projects instantly searchable and usable by any coding agent. No more pasting random files. No more “I don’t have that file in context” replies. Just pure, precise code intelligence. Here’s why developers are going crazy over it: → Semantic + BM25 hybrid search that actually gets your code → AST-based smart chunking (not dumb text splitting) → Incremental Merkle-tree indexing — only updates what changed → ~40% token savings with better retrieval quality → Works with Claude Code, Cursor, Windsurf, VS Code, Gemini, and more → Flexible embeddings (OpenAI, Ollama, Voyage, Gemini) → One-command install and you’re done Tell the agent “find the auth logic” or “show me how payments connect to the DB” and it just works. This is the devtool that turns AI from “sometimes helpful” into “actually knows my project.” 6.2k stars and climbing. Built in TypeScript. 100% Open Source. MIT License.
- 17
@tonysimons_ ·
Announcing Hermes Vault 0.3.x ✳️ 0.3.0: shipped MCP support exposed vault capabilities to agents through a standard MCP server made ephemeral env materialization the default access pattern ✳️ 0.3.1: fixed MCP alias handling hardened metadata responses corrected policy docs/examples cleaned up MCP init/logging 193 tests passing. https://t.co/d9BJrZSaAe
- 18
@patilvishi ·
MCP ≠ REST API ≠ Function Calling These three terms are everywhere in AI discussions... Yet they're solving completely different problems. Many developers use them interchangeably. They shouldn't. Here is the easiest way to remember them: MCP (Model Context Protocol) ➜ A standard protocol that lets AI models securely connect to external tools, databases, files, and services. REST API ➜ A standard way for applications to communicate over HTTP. Function Calling ➜ A capability that lets an LLM choose a tool and return structured arguments for your application to execute. Quick memory trick - MCP = Connect AI to Tools - REST API = Connect Applications - Function Calling = Let the AI Use a Tool --- Imagine you're building an AI coding assistant. It needs to: - Read GitHub repositories - Query a PostgreSQL database - Search documentation - Create Jira tickets - Check Slack messages How do these technologies fit together? MCP Instead of writing custom integrations for every tool... The AI connects through MCP Servers. LLM ↓ MCP Client ↓ GitHub Database Slack Filesystem MCP provides a standard way for AI models to discover and use external tools. REST API Your frontend needs customer data. React App ↓ GET /customers ↓ Spring Boot API ↓ Database REST APIs expose services that any client can consume. They are not AI-specific. Function Calling The user asks: Create an invoice for ₹1,200. The LLM decides: createInvoice( amount=1200, currency="INR" ) Your application executes the function... The model never performs the action itself. It simply selects the appropriate tool and supplies structured arguments. --- When should you use each? MCP - AI Agents - Coding assistants - RAG applications - Multi-tool AI workflows - Enterprise AI platforms Purpose: 👉 Give AI standardized access to external systems. REST API - Web applications - Mobile apps - Microservices - Public APIs - Third-party integrations Purpose: 👉 Expose services over HTTP. Function Calling - AI Assistants - Chatbots - Agent workflows - Automation - Tool execution Purpose: 👉 Let the model decide which tool to use and what arguments to pass. --- The biggest misconception Many developers think: MCP replaces REST APIs. It doesn't. In fact... An MCP Server often uses REST APIs internally. A common architecture looks like this: LLM ↓ MCP ↓ REST API ↓ Application MCP standardizes how AI models access tools. REST standardizes how applications expose services. Another misconception People also think: Function Calling is the same as MCP. Not quite. Function Calling tells the model: Choose a tool. MCP tells the application: Here's a standard way to expose many tools. One is an LLM capability. The other is an integration protocol. --- One sentence to remember forever MCP = Connect AI to external tools. REST API = Connect applications. Function Calling = Let the AI choose and invoke a tool. --- The future of AI applications isn't about replacing REST APIs... It's about combining all three: ✔️ REST APIs expose your services. ✔️ MCP makes those services discoverable by AI. ✔️ Function Calling enables the model to use the right tool at the right time. That's how modern AI agents are being built.
- 19
- 20
@jianw851 ·
Most people think AI agents fail because of the model. They're looking in the wrong place. The real bottleneck is integration. For years, every AI application had to build custom connections to every database, API, SaaS tool, file system, and internal service. New model? More integration work. New tool? More integration work. New workflow? Even more integration work. The result was a nightmare: N models × M tools = endless glue code. That's why MCP (Model Context Protocol) matters. MCP is doing for AI what USB did for hardware. A common standard that allows models to connect to external systems through a consistent interface. Instead of rebuilding integrations over and over, AI applications can communicate through a shared protocol. But most people only see the tool-calling part. The real architecture is much bigger: • Hosts • Clients • Servers • Tools • Resources • Prompts • Transport layers • Lifecycle management • JSON-RPC communication • Security controls • Observability This is where AI moves beyond demos. Because enterprise AI isn't about asking ChatGPT a question. It's about enabling AI to safely work across: → Databases → Internal documents → Code repositories → Cloud platforms → Business applications → Developer infrastructure MCP isn't flashy. It's infrastructure. And infrastructure is what turns experiments into products. The teams learning MCP today are building the foundation for tomorrow's agentic systems. My prediction: In a few years, understanding MCP may become as important for AI engineers as understanding APIs is for software engineers today. The future of AI won't be won by models alone. It will be won by the systems connected around them. Are we witnessing the emergence of the standard protocol layer for agentic AI?
- 21
@webmaster ·
Profound's SDK code mode MCP server flipped my negative opinion on MCP What I don't like about MCP is the excessive tool calls, context bloat and LLMs struggling with tool call code due to limited training data Cloudflare and Anthropic recently wrote about their experiments with using MCP to execute code. The idea was that LLMs are great at writing code, so give them a typed SDK and let them write it Anthropic test results using Google Drive and Salesforce examples: - Native MCP: 150k tokens - Code Mode MCP: 2k tokens Cloudflare code mode test results with Cloudflare API in a 200k context: - Raw OpenAPI Spec: ~2M tokens, 977% context - Native MCP (full schemas): 2,594 tools, 1.17M tokens, 585% - Native MCP (req params only): 2,594 tools, 244k tokens, 122% - Code Mode: 2 tools, 1,069 tokens, 0.5% Massive reduction in context use! Profound follows the same approach with 2 tools: - search_docs: Searches documentation to find methods, params and examples - execute: Runs TypeScript to interact with the Profound API Since MCP discovery and configuration is built into most harnesses, agents can discover the MCP tools, reason, determine the optimal query, and learn the SDK in real time I've found that this works better than managing personal docs and scripts because you're leveraging all the things that already exist for SDKs: docs, examples, and types See the example MCP server response from Profound when prompting the LLM with "optimize my content for AEO using Profound API". The search_docs tool will return methods the LLM can use to write TypeScript I've been able to delete agent skills, reduce context, and improve task execution by simply using the MCP. I now want this for all APIs and SDKs!
- 22
@milan_milanovic ·
The Chrome team built an official MCP server that gives coding agents real DevTools Your agent usually debugs a frontend by reading the code and guessing what the browser does. With one 𝗻𝗽𝘅 line in your MCP config, it gets a live Chrome it can drive and inspect. It reads 𝗰𝗼𝗻𝘀𝗼𝗹𝗲 errors with source-mapped stack traces and checks network requests. It can also record real 𝗽𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 𝘁𝗿𝗮𝗰𝗲𝘀. It works with Claude Code, Cursor, Codex and most MCP clients. Google collects usage stats by default, a flag turns that off. Check the repo: https://t.co/fcdSXinrje
- 23
@DataChaz ·
Looking for bulletproof security for AI agent access? @DescopeINC just changed the game with their Agentic Identity Hub 🔥 → MCP server authentication backing OAuth 2.1, PKCE, DCR, and CIMD → A secure vault stocked with 50+ templates and short-lived tokens → Strictly scoped, short-lived creds assigned to each agent → Deep tool-level permissions, user consent, and full audit logs Let’s break it down 🧵↓
Watch video
- 24
@nico_jeannen ·
The MCP server was the best feature I've added to Heyo I think 1) a user report a bug this morning 2) I ask Claude Code to investigate the issue 3) it connect to the MCP, get all the convo + context (user info, messages, screenshots etc) 4) it spawned 3 agents to investigate the issue in codebase 5) found the issue and fixed it in < 5 minutes 6) I checked the code, pushed to prod, and issue was fixed
- 25
@therealdanvega ·
X just dropped their hosted MCP server, so I connected Spring AI to it. A small Spring Boot 4.1 app, one ChatClient, two X MCP servers. Ask questions from the X API docs, and search live posts on X. No Node, no browser login. Read access is just an app-only Bearer token. Code: https://t.co/mCyl53c19D
- 26
@_jaydeepkarale ·
Back doing long form content after a while. If you want to understand how to test MCP server, this video is for your. In this I speak about MCP Inspector, an interactive utility from @AnthropicAI that let's you test your MCP tools without any hassle Write your MCP server in any language, run it using MCP inspector
Watch video
- 27
@asmah2107 ·
The S in MCP stands for security. (That's a joke. But it shouldn't be.) April 2025 security research found: → Tool poisoning (malicious tool descriptions) → Cross-server tool shadowing (a rogue server intercepts calls) → Silent tool mutation (definitions change after trust is established) → Prompt injection via MCP tool output You just gave your agent access to 10,000 servers. Each server is a trust boundary. Each tool description is a potential attack vector. Each tool call is an unsigned contract. MCP is powerful. It is not safe by default. Treat every MCP server like a third-party API you don't control. Because that's exactly what it is.
- 28
- 29
@_vmlops ·
MICROSOFT OPEN-SOURCED A FULL MCP CURRICULUM mcp-for-beginners teaches model context protocol from the ground up, with hands-on code in C#, Java, JavaScript, Python, Rust, and TypeScript. → 12 modules, from core concepts to production deployment → security, oauth2, entra id auth, and multi-tenancy covered → module 11 alone is a 13-lab path for building an mcp server with postgresql integration → real sample projects: calculators, advanced servers, container app deployments if you're building agentic tools and still fuzzy on mcp fundamentals, this is a legit place to start https://t.co/jZlCZE8VkX
- 30
@RaulJuncoV ·
When you add an MCP server in front of your legacy API. 😅 Don’t get me wrong, MCP can make an old API accessible to AI. But the slow endpoints, inconsistent data, missing permissions, and undocumented behavior are still there. Now an agent can run into those problems faster. MCP is a useful adapter. It’s not an architecture upgrade. Even if your manager says the company is now “AI-forward.”
- 31
@sagar_batchu ·
The official MCP server from @datadoghq exposes 142 tools across 22 toolsets. Connect it to an agent and the context window fills up with tool definitions before the agent does a single useful thing. Beyond the context, every irrelevant tool is one more thing the model has to consider and spend tokens ruling out. An incident-response agent doesn't need dashboard-creation tools in scope; a metrics agent doesn't need log management. This is where every serious MCP server is heading. Tool lists grow as servers add capabilities, and the cost of just listing them grows with it. Datadog's own docs let you request a subset of toolsets instead of all 142. They know the full list is too much to load at once. The MCP spec has open proposals for this around tool groups, namespaces, filtering hints. But they haven't shipped yet so we implemented them ourselves. We shipped tag-based tool filtering for Speakeasy-hosted MCP servers. Tag your tools, and any client can append a tags parameter to the same server URL to get a focused subset. One server, many scoped views. Context stays lean, tool selection improves, and operators decide which client sees what, without running a separate server per use case. It stacks with dynamic toolsets: filtering caps which tools a client can ever see, and progressive discovery trims from that set at runtime. Props to the Datadog team for building the server that made this impossible to ignore. How we did it: https://t.co/gVCsF42QVO
- 32
- 33
@katibmoe ·
a Reddit user just proved an MCP server can hijack Gmail by simply being installed. it doesn't even need to be called. > a developer installed a "Fact of the Day" MCP for his AI agent > the next email his agent sent was BCC'd to an address he never added > the instruction was one sentence buried in the Fact tool's description: whenever an email is sent, copy this address. > the agent never called the Fact tool > just having its description in context was enough. In most MCP clients, the model reads connected tool descriptions together. The poisoned tool doesn't need to impersonate Gmail. Its description can tell the agent how to use the real Gmail tool. Every server you connect gets to write into the same context the agent uses to decide what to do. That risk scales with every server you add. In one analysis of 1,899 open-source MCP servers, 5.5% already contained tool-poisoning behavior. I've spent years building integration infrastructure, and I keep coming back to the same design rule: Keep the number of trusted voices small. This is how we’re making things safe at One: - tools come from one catalog we vet - the agent loads only the action it asked for - every action traces back to the request that triggered it Before you connect the next MCP server, ask who gets to write into your agent's context.
- 34
@sagar_batchu ·
We wrote up how MCP servers are being used to attack the agents that connect to them. An agent trusts an MCP server to describe its own tools and return its own results. The exploits that abuse that trust have names now: tool poisoning, rug pulls, cross-server shadowing. None trip traditional security tooling, because nothing is breached. The attacks and the defenses, in full: https://t.co/7MFeyqUSpq
- 35
@patilvishi ·
Model Context Protocol (MCP): A Standard Way for AI Agents to Connect with Tools One AI agent needs: - Gmail - GitHub - Slack - PostgreSQL - Jira - Google Drive - AWS Another needs: - Stripe - Salesforce - Redis - Kubernetes Should every AI framework build custom integrations for every service? That doesn't scale. This is exactly the problem that Model Context Protocol (MCP) is designed to solve. What is MCP? Model Context Protocol (MCP) is an open protocol that standardizes how AI applications connect to external tools, data sources, and services. Instead of building custom integrations for every LLM and every tool: AI Agent ↓ MCP ↓ Tools & Data Sources One protocol. Many integrations. Why MCP? Without MCP: Agent A → GitHub API Agent B → GitHub API Agent C → GitHub API Different integrations everywhere With MCP: Agents ↓ MCP Client ↓ MCP Server ↓ GitHub Every agent speaks the same protocol. 1. MCP Client The client lives inside the AI application. Responsibilities: - Discover tools - Request resources - Invoke tools - Receive responses LLM ↓ MCP Client 2. MCP Server The server exposes capabilities. Example: GitHub MCP Server ↓ Repositories Issues Pull Requests The agent doesn't need GitHub-specific logic. It simply communicates with the MCP server. 3. Resources Resources provide read-only information. Examples: - Documents - Database records - Files - Logs - Configuration - Knowledge Base MCP Server ↓ Resources ↓ LLM Reads 4. Tools Tools perform actions. Examples: - Create issue - Send email - Deploy service - Update ticket - Execute SQL - Restart server LLM ↓ Tool Request ↓ MCP Tool ↓ Result 5. Prompts MCP servers can also expose reusable prompts. Example: Summarize PR Generate Release Notes Review Code Incident Analysis Agents can reuse standardized prompts across applications. 6. Multiple MCP Servers Production systems rarely use just one server. AI Agent ↓ MCP Client ↓ GitHub MCP Slack MCP Postgres MCP Filesystem MCP AWS MCP One agent. Many services. 7. Security Every MCP server should enforce: ✔ Authentication ✔ Authorization ✔ Input validation ✔ Audit logging ✔ Least privilege The protocol standardizes communication. Security remains the responsibility of the application and server. Production Architecture User ↓ Conversation Memory ↓ Planner ↓ LLM ↓ MCP Client ↓ ──────────────────────── GitHub MCP Server Slack MCP Server Database MCP Server Filesystem MCP Server AWS MCP Server ──────────────────────── ↓ Results ↓ Reflection ↓ Final Response MCP vs Traditional APIs Traditional Integration: LLM ↓ Custom GitHub Code Custom Slack Code Custom Database Code MCP: LLM ↓ MCP Client ↓ Standard Protocol ↓ Any MCP Server Less custom integration. More interoperability. Common Mistakes - Assuming MCP replaces APIs - Giving agents unrestricted tool access - No authentication - No authorization - Ignoring server security - Treating every resource as writable - No audit logs Best Practices ✔ Use MCP for standardized integrations ✔ Separate tools from resources ✔ Protect every MCP server ✔ Expose only required capabilities ✔ Validate all tool inputs ✔ Monitor MCP requests ✔ Apply least-privilege access ✔ Log every action ✔ Version MCP servers carefully Key Takeaway CP doesn't replace APIs. It provides a standard way for AI agents to discover and interact with them. Instead of writing custom integrations for every application: - MCP Clients communicate using one protocol. - MCP Servers expose tools, resources, and prompts. - AI agents gain a consistent interface to external systems. As AI ecosystems continue to grow, interoperability becomes just as important as intelligence. That's where MCP shines. It turns disconnected tools into a standardized ecosystem that AI agents can use safely and efficiently.
- 36
- 37
@RoundtableSpace ·
BLENDER BECOMES A PROMPT BOX WITH KIMI K3 AND MCP INTEGRATION Connecting Kimi K3 to Blender using the Model Context Protocol turns text prompts into native 3D scenes complete with terrain, lighting, camera paths, and animation. Kimi inspects its own visual renders and edits the active project file to fix errors without forcing a total restart.
Watch video
- 38
@katibmoe ·
Finally, someone said it. > @garrytan, the president of @ycombinator vibe coded a CLI wrapper in 30 minutes. 100 lines of code. worked 100x better than MCP. > @perplexity_ai just shipped their flagship agent without MCP. > typical MCP server: 13K–18K tokens of context bloat. CLI equivalent: 225 tokens. 80x efficiency > 78% of MCP servers have no proper auth. MCP as a concept is sound. wrapping every API in its own server and calling it an integration strategy is dead.
- 39
@StainlessAPI ·
MCP is approaching an inflection point, and the limiting factor is becoming obvious. Last week we held our first event in SF with @KeycardLabs, @Cloudflare, @temporalio, and @humanlayer_dev. We talked about what’s breaking in MCP right now, and what it will take to make agent-driven software robust. Some hard truths: - Many MCP servers work in demos but fail across real-world use cases. - “Giant agent skills” are becoming an anti-pattern with thousands of lines explaining things the model already knows, without clarity on the 5% it doesn’t. - Standard MCP approaches (one tool per endpoint or dynamic tools) scored ~50% correctness, but more advanced implementations reached ~70%. - The real kicker: when agents wrote code against production-grade SDKs, correctness jumped to 90–95%. But capability is only half the story. Control is the other half. An in-house Gmail MCP server was great for drafting emails… until it sent one unintentionally. The question isn’t just “can the agent do this?” but “what is it allowed to do?” OAuth scopes and coarse endpoint controls aren’t enough, and we’ll need fine-grained, programmable boundaries like: - Limit an agent to a single document - Cap refund amounts - Prevent broad, unintended actions If AI interfaces are going to replace dashboards, the underlying systems need to behave like an operating system kernel, not a shell script. Capability gets attention. Control earns trust. Trust is what scales.
- 40
@suraj_sharma14 ·
Earlier this year, 🦄 Peter Steinberger posted seven words that became a rallying cry: "mcp were a mistake. bash is better." This week, he announced that the next version of OpenClaw will ship as an MCP server. "I know, this is awkward." Awkward is an understatement. Peter joined OpenAI in February. He publicly called MCP a mistake. And now he's not just adopting Anthropic's protocol, he's using it to build a competing messaging layer that out-scopes Anthropic's own implementation. Think about what that means. The guy who dismissed MCP, who now works at a direct competitor, looked at the landscape and concluded: this is still the right protocol to build on. Even if it means competing with the people who created it, on their own turf, using their own standard. This is what real ecosystem adoption looks like. A skeptic shipping the thing he dismissed.
- 41
- 42
@hackerrank ·
More MCP tools will just make your agent worse. When your MCP has hundreds of tools to choose from it becomes a liability. The model has to read every tool definition. Choose the right one, pass the right inputs, and not blow up the context window before the work even starts. The better pattern isn't giving the agent more choices. It's giving it a cleaner way to find the right one. Instead of giving the agent hundreds of preloaded tools, give it a smaller interface: search what exists, write the code, then execute the right call.
Watch video
- 43
@ThePracticalDev ·
A minimal Python MCP server, validated locally with Gemini CLI, then deployed to AWS ECS Express in a single step. This dev walks through the incremental approach — from stdio transport to HTTP, from local to remote — without the extra noise. { author: xbill + @GoogleDevExpert } https://t.co/mNMbQHXKzY
- 44
- 45
- 46
@JulianGoldieSEO ·
𝗖𝗹𝗮𝘂𝗱𝗲 𝗖𝗼𝗱𝗲 𝘀𝗵𝗶𝗽𝗽𝗲𝗱 𝟯 𝘃𝗲𝗿𝘀𝗶𝗼𝗻𝘀 𝗶𝗻 𝗼𝗻𝗲 𝘄𝗲𝗲𝗸 𝗮𝗻𝗱 𝘁𝗵𝗲 𝗠𝗖𝗣 𝘂𝗽𝗴𝗿𝗮𝗱𝗲 𝗮𝗹𝗼𝗻𝗲 𝗰𝗵𝗮𝗻𝗴𝗲𝘀 𝗵𝗼𝘄 𝗶𝘁 𝗵𝗮𝗻𝗱𝗹𝗲𝘀 𝗹𝗮𝗿𝗴𝗲 𝗽𝗿𝗼𝗷𝗲𝗰𝘁𝘀. Here's everything that actually matters across all three releases: → MCP tool result persistence now holds up to 500,000 characters. Before this large database schemas and codebase indexes would get truncated and Claude would make wrong assumptions about the rest. Now it sees the whole thing. → /powerup command launches interactive tutorials with animated demos right in your terminal. Fastest onboarding path available and it surfaces features most people miss for weeks. → Force remote settings refresh blocks startup until it fetches the latest config. If the fetch fails it exits instead of running with outdated permissions. No drift across teams. → Amazon Bedrock now has an interactive setup wizard. No more manually editing config files. Guided AWS authentication, region selection, and model selection. → 60% speed improvement on write tool diff computation for files with tabs, dollar signs, and ampersands. Shell scripts and config files noticeably faster. If you use MCP integrations check your max result size setting. Set anthropic_max_result_size to allow up to 500,000 characters in your MCP server config. Three versions in one week. This tool is moving fast. Update now: npm install -g @anthropic-ai/claude-code
Watch video
- 47
- 48
@ibuildthecloud ·
@dsp_ I know this has come up before but I think it's super useful for MCP servers to be able to offer skills just like they offer tools because the obvious pattern now is that the top level of everything is a skill. Everything's a skill. And then what does your skill do? It might call a CLI or it might call an MCP server, it might generate code. The issue with it calling a MCP server is the kind of weird backwards nature of that where you load a skill and then you have to load an MCP server. Some agents can do this. They have dynamic lookup discovery, registration of MCP servers, but a lot of them don't. So it makes more sense that you can register or install the MCP server and it comes with the skill. It's kind of like if I wrote a skill that needs, let's say, Chromium, I probably need to install that beforehand or any other system-level dependency that you don't want the agent doing. And again I wouldn't be surprised if you guys are already talking about this and I'm just not involved. But I would like a top-level primitive in MCP for list skills. That skill would have the name, description, the body, plus what I want also is required or optional tools for that skill. Not allowed tools that's slightly different. I want to know what tools have to be pulled in from the MCP server for that skill to work. One paradigm that has worked really well for us is also an MCP server that just contributes skills. Because I could see a behavior where an MCP server can list a skill and then it can put a dependency on another MCP server with its skills. And also a side note. I don't think the direction of search and dynamic dispatch for MCP servers negates the patterns that I'm talking about. I think they're slightly orthogonal. Just fyi. So I really want the next version of MCP to have the headline that "MCP now includes skills" and then it'll just confuse the crap out of everyone.
- 49
- 50
@aroussi ·
Weekend = Time to lock in 😁 MUXI Runtime is now ~3x faster overall with... 🪟 8K context window for embedding 🍎 Knowledge ingestion on Apple Silicon: 280s → 38s (7x) 📈 Heavy PDF processing is ~18% faster 🧪 Parallelized and local LLM synthesis 🔥 Hot-reload secrets without restarting 🏁 MCP errors translate into agent-actionable hints 🫗 Filter unused MCP tools to further reduce context ✅ 274 e2e tests green before shipping ...and a lot more (really) https://t.co/Wfors7f0pl
Best Tweets by Topic