r/mcp • • May 29 '25

discussion Probably gonna get a lot of hate for this but MCP... after studying it, it looks pretty useless to me

0 Upvotes

Firstly, a MCP server exposes, tools, resources and prompts. Now, given that you might not want to expose implementation details of a tool with a user so client-server model makes sense. However, let's look at a SaaS use-case to see why it doesn't help:

  • a user's data residing on client side has to be exchanged with server every time for it to take the right steps.

  • any data generated via client-server interactions, memory of it has to be implemented on client side, bloating it over time. MCP server implementation, the way it is right now, forces the data to reside away from the server making it essentially the same as REST API.

  • MCP server model forces more resources to run on server-side, where the same functionality could have been achieved by endpoints with the format let's say /api/v1/ai-tool/*

Plus MCP adds a layer of complexity where it's often not needed. I like the standardization of model context however I do not think the implementation is ideal.

IMO, at its core MCP is just a prompt template being populated via various tools made to look a bit fancier.

What do you guys think? Am I missing something?


r/mcp • • Sep 13 '25

mcp-glootie Is released, and it has the potential to be the killer MCP tool

6 Upvotes

github.com/anentrypoint/mcp-glootie
mcp-glootie (previously mcp-repl) is a tool that's made by devs, for devs.

It's an agentic coding optimizer that aims to improve on the output and wall clock problem solving performance of your programming agent.

It extrapolates on a senior developers preferred workflows and diagnostic processes, and seeks to find a way to make that type of functionality available to agents.

The general thinking is if 50% of a senior developers coding effort is spent on this tool, then many best practices in a way that other developers can pick up on and hopefully one day improve on.

What glootie DOES do:

Execute code first before doing any editing. You wont believe what advantage you get from just that, you have to see it to believe it, it encourages the working agent to prefer hypothesizing code and testing it before editing files, grounding its edits further in truth, it gets to do this in the repo, with the libraries available to it, for node, deno, and bash.

Do semantic code searching (a fast and compatible semantic code search is embedded in glootie, allowing agents to search code quickly and effectively), this gets rid of the need for third party code searches like augment

Allow your agent to make surgical code updates with ast-grep tools, ast functionality is native to AI these days, you get a huge performanace boost from access to it.

Internal batch capabilities allows the agent to trade multi turn latency for bundling... drastically reducing the turnaround speed of steps where the provider has a turnaround delay imposed.

Built in step by step reasoning to replace other popular MCP tools with a much more optimized version of the process, kerned for daily use and token reduction, a key featue is the agent can assign these reasoning processes to a proeject folder the same way it executes code in a project folder, allowing for easy cross-repo work to occur intelligently.

What glootie DOESNT do:

glootie is not a product its an in-house programming tool for an independent developer, you can receive the same benefits without making the same tools, but there's no company and there's no service.

Let me know what you think of glooties performance, I've amassed 17 stars on github, making it IMHO currently the most undervalued MCP tool

EDIT:

6 Days, 34k views (half of the MCP community!) later and glootie now has 87 stars! I'm really looking forward to finding out how a larger userbase experiences it... There's a new post incoming today about glooties new version, which is benchmark based:

I'll have to write a whole post about what I've learnt, by grounding the next phase of development with some self driven QA and strong guardrails, I've managed to create strong insights to some key indicators of its performance, very interesting stuff... It's taken quite a few days to break all the eggs and remake the omelette but its pretty much ready, doing some last tests now.

Note: the new glootie includes WFGY 2.0: https://github.com/onestardao/WFGY/blob/main/core/WFGY_Core_OneLine_v2.0.txt which is aimed at driving the LLM's a bit harder during complex tasks. If anybody doesnt like this inclusion, we can replace it with something better

A note: the next version launching today might be a little claude code specific, I'll be interested in finding out what mileage people are getting from other coders now, since we're benchmarking on claude code and referring to tools such as 'TodoWrite'.


r/mcp • • Dec 16 '25

question Why is nobody talking about 'Tool Poisoning' in the MCP ecosystem?

0 Upvotes

I’ve been diving deep into MCP lately, and while the connectivity is amazing, the security side is keeping me up at night.

We’re giving agents direct access to databases and internal APIs, but standard MCP seems to lack "real" guardrails. Most discussions I see just say "don't give the agent dangerous tools," but that feels like a weak strategy against prompt injection or confused context.

I was looking for middleware that actually inspects the traffic (not just the prompt) and found a server where they talk about a "4D security" approach, specifically "Deep Inspection" of every tool call and "Context-Aware" access control.

It looks promising because it treats the agent like an untrusted user rather than a magical box.

Before I go down the rabbit hole with their implementation:

  1. How are you guys currently securing your MCP servers?

  2. Is anyone else using an inspection layer like Gopher, or are you building custom middleware?

  3. Is "post-quantum encryption" (which they offer) actually necessary for MCP right now, or is that overkill?

I would love to know how y'all are tackling this.


r/mcp • • Nov 04 '25

4 MCPs Every Backend Dev Should Install Today

18 Upvotes

TL;DR

Here are the 4 MCP servers that eliminate my biggest time sinks in backend development:

  1. Postgres MCP - Your AI sees your actual database schema

  2. MongoDB MCP - Official MongoDB Inc. support for natural language queries

  3. Postman MCP - Manage collections and environments via AI

  4. AWS MCP - Infrastructure as code through natural language

Let's break down what each one actually does and how to install them.

1. Postgres MCP: Your AI Can Finally See Your Database

Here's what kills backend productivity: You ask your AI to write a database query. It generates something that looks right. You run it. Error. The column doesn't exist. The AI was guessing.

You open pgAdmin. Check the schema. Fix the query manually. Copy it back. Five minutes gone. You do this 50 times a day.

Postgres MCP fixes this. Your AI sees your actual database schema. No guessing. No hallucinations.

What Actually Changes

Before MCP: AI generates queries from outdated training data. After MCP: AI reads your live schema and generates queries that work the first time.

Three Paths: Pick Based on Risk Tolerance

Path 1: Read-Only (Production Safe)

Anthropic's reference implementation (now archived). One tool: query. That's it. Your AI can inspect schemas and run SELECT statements. It cannot write, update, or delete anything.

Config:

{
  "mcpServers": {
    "postgres": {
      "command": "docker",
      "args": ["run","-i","--rm","-e","POSTGRES_URL","mcp/postgres","$POSTGRES_URL"],
      "env": {"POSTGRES_URL": "postgresql://host.docker.internal:5432/mydb"}
    }
  }
}

Use this for production databases where one wrong command costs money.

Path 2: Full Power (Development)

CrystalDBA's Postgres MCP Pro supports multiple access modes to give you control over the operations that the AI agent can perform on the database:

  • Unrestricted Mode: Allows full read/write access to modify data and schema. It is suitable for development environments.

  • Restricted Mode: Limits operations to read-only transactions and imposes constraints on resource utilization (presently only execution time). It is suitable for production environments.

Use this for dev databases where you need AI-powered performance tuning and optimization, not just query execution.

Path 3: Supabase Remote (Easiest)

If you're on Supabase, their Remote MCP handles everything via HTTPS. OAuth authentication. Token refresh. Plus tools for Edge Functions, storage, and security advisors.

Setup time: 1 minute. Paste a URL. Authenticate via browser. Done.

Real Scenario: Query Optimization

Your API is slow. Something's hitting the database wrong.

Old way: Enable pg_stat_statements. SSH to server. Query for slow statements. Copy query. Run EXPLAIN. Guess index. Test. Repeat. 45 minutes.

With Postgres MCP:

You: "Show me the slowest queries"
AI: [Queries pg_stat_statements via MCP]
    "Checkout query averaging 847ms. 
     Missing index on orders.user_id"
You: "Add it"
AI: [Creates index]
    "Done. Test it."

3 minutes.

The AI has direct access to pg_stat_statements. It sees your actual performance data. It knows which extensions you have enabled. It generates the exact query that works on your setup.

Best Practice

Sometimes the Postgres MCP might return '⚠ Large MCP response (~10.3k tokens), this can fill up context quickly'"

Reality check: When your AI queries a 200-table schema, it consumes tokens. For large databases, that's 10k+ tokens just for schema inspection.

Solution: Be specific. Don't ask "show me everything." Ask "show me the users table schema" or "what indexes exist on orders."

The Reality Check

This won't make you a better database designer or replace knowing SQL. It removes the friction between you and your database when working with AI, but you still need to understand indexes, performance, and schema design to make the final decisions.

You'll still need to know indexes. Understand performance. Design good schemas. Make the actual decisions.

But you'll do it faster. Because your AI sees what you see. It's not guessing from 2023 training data. It's reading your actual production schema right now.

The developers who win with this treat it like a co-pilot, not an autopilot. You make the decisions. The AI just makes them faster by having the actual context it needs to help you.

Install one. Use it for a week. Track how many times you would have context-switched to check the schema manually. That's your time savings. That's the value.

2. MongoDB MCP: Stop Writing Aggregation Pipelines From Memory

The MongoDB developer tax: You need an aggregation pipeline. Open docs. Copy example. Modify. Test. Fails. Check syntax. Realize $group comes before $match. Rewrite. Test again.

Your AI? Useless. It suggests operators that don't exist. Hallucinates field names. Writes pipelines for MongoDB 4.2 when you're on 7.0.

MongoDB MCP Server fixes this. Official. From MongoDB Inc. Your AI sees your actual schema, knows your version, writes pipelines that work first try.

What Official Support Means

Official MongoDB Inc. support means production-ready reliability and ongoing maintenance.

22 tools including:

  • Run aggregations

  • Describe schemas and indexes

  • Get collection statistics

  • Create collections and indexes

  • Manage Atlas clusters

  • Export query results

Everything you do in Compass or mongo shell, your AI now does via natural language.

The Read-Only Safety Net

Start the server in --readOnly mode and use --disabledTools to limit capabilities.

Connect to production safely. Read-only locks it to inspection only. No accidental drops. No deletes. For dev databases, remove the flag and get full CRUD.

Three Paths: Pick One and Install

Local MongoDB (npx):

{
  "mcpServers": {
    "MongoDB": {
      "command": "npx",
      "args": ["-y","mongodb-mcp-server","--connectionString",
               "mongodb://localhost:27017/myDatabase","--readOnly"]
    }
  }
}

MongoDB Atlas (API credentials):

{
  "mcpServers": {
    "MongoDB": {
      "command": "npx",
      "args": ["-y","mongodb-mcp-server","--apiClientId","your-client-id",
               "--apiClientSecret","your-client-secret","--readOnly"]
    }
  }
}

This unlocks Atlas admin tools. Create clusters, manage access, check health—all in natural language.

Docker:

{
  "mcpServers": {
    "mongodb": {
      "command": "docker",
      "args": ["run","-i","--rm","-e","MDB_MCP_CONNECTION_STRING","mcp/mongodb"],
      "env": {"MDB_MCP_CONNECTION_STRING": "mongodb+srv://user:[email protected]/db"}
    }
  }
}

Real Scenario: Aggregation Development

Building analytics endpoint. Need orders grouped by region, totals calculated, top 5 returned.

Old way:

  1. Open MongoDB docs

  2. Copy pipeline example

  3. Modify for your schema

  4. Test in Compass

  5. Fix syntax

  6. Copy to code

  7. Debug field names

  8. Fix and redeploy

Time: 25 minutes per pipeline. 20 times per feature = 8+ hours.

With MongoDB MCP:

You: "Group orders by region, sum revenue, return top 5"
AI: [Checks schema via MCP]
    [Generates with correct fields]

{ pipeline: [
  { $group: { _id: "$region", totalRevenue: { $sum: "$amount" }}},
  { $sort: { totalRevenue: -1 }},
  { $limit: 5 }
]}

Time: 45 seconds.

AI sees your schema. Knows amount is the field, not total. Uses operators compatible with your version. Works immediately.

Schema Inspection Without Leaving Code

Debugging production. Need to check field distribution.

Without MCP: Open Compass. Navigate. Query. Check. Copy. Context switch.

With MCP:

You: "Do all users have email field?"
AI: "Checked 847,293 docs. 99.7% have email. 
     2,851 missing. Want me to find them?"

Your AI becomes a database analyst that knows your data.

Atlas Administration

If you use Atlas, MCP includes cluster management tools.

Your AI can:

  • Create projects and clusters

  • Configure access

  • Check health

  • Review performance

All in natural language. In your IDE.

Reality Check: MongoDB MCP

It removes syntax barriers, but it won't make you a better database designer. You still need to understand pipelines, indexing, and document structure to make key architectural decisions.

You'll just do it faster. Your AI sees actual schema, not guessed field names from training data.

Developers who win use this to accelerate expertise, not replace it.

3. Postman MCP: Stop Clicking Through Your API Collections

The API development tax: You're building an endpoint. You open Postman. Create a collection. Set up environment variables. Write tests. Switch back to code. Update the API. Switch back to Postman. Update the collection. Update the environment. Update the docs. 20 clicks for what should be one command.

Your AI? Completely disconnected. It can't see your collections. Can't update environments. Can't sync your OpenAPI specs. Can't run your tests.

Postman MCP Server changes this. Official. From Postman Labs. Your AI manages your entire API workflow through natural language.

What Official Postman Support Means

Not a third-party hack. Postman built this. They maintain it. They're betting on AI-driven API development.

38 tools in the base server, including:

  • Create and update collections

  • Manage environments and variables

  • Sync OpenAPI specs with collections

  • Create mock servers

  • Manage workspaces

  • Duplicate collections across workspaces

September 2025 update added 100+ tools in full mode. Everything you click in the Postman UI, your AI can now do via prompts.

Setup: Docker (Cursor for example)

Connect the MCP Toolkit gateway to your Cursor:

docker mcp client connect cursor -g

Install Postman MCP server:

docker mcp server enable postman

Paste the Postman API Key into Docker MCP Toolkit > Postman

Real Backend Scenario: OpenAPI Spec Sync

You're building with Django REST Framework. You generate OpenAPI specs from your code. You need them in Postman for testing.

Old way:

  1. Generate OpenAPI spec from DRF

  2. Export as JSON

  3. Open Postman

  4. Import spec

  5. Update collection

  6. Hope nothing breaks

  7. Check endpoints manually

  8. Fix mismatches

Time: 15 minutes every time your API changes.

With Postman MCP:

You: "Sync my Django OpenAPI spec with Postman collection"
AI: [Uses syncCollectionWithSpec tool]
    "Spec synced. 12 endpoints updated, 3 new endpoints added."

Time: 30 seconds.

The tools syncCollectionWithSpec and syncSpecWithCollection are built-in. Your AI keeps your Postman collections in sync with your code automatically.

Reality Check: Postman MCP

This won't make your APIs better designed. Won't fix slow endpoints. Won't write your tests for you.

What it does: Removes the Postman UI tax when managing API infrastructure.

You still need to:

  • Design good API contracts

  • Write meaningful tests

  • Structure collections properly

  • Set up proper authentication

  • Document endpoints clearly

You'll just do it faster. Because your AI has direct access to your Postman workspace. It's not screenshotting the UI. It's calling the actual Postman API that powers the UI.

Developers who win with this use it to eliminate repetitive collection management, not replace API design expertise.

4. AWS MCP: Stop Writing CloudFormation YAML

The infrastructure tax backend devs pay: You need an S3 bucket. With versioning. Encrypted with KMS. Maybe CloudFront. You open the AWS console. Or you write CloudFormation. Or Terraform. Either way, you're context-switching, clicking through wizards, or writing YAML for 30 minutes to create something that should take 30 seconds.

Your AI? Can't touch AWS. It hallucinates IAM policies. Suggests services that don't exist in your region. Writes Terraform that fails on apply.

AWS Cloud Control API MCP Server fixes this. Official. From AWS Labs. Your AI manages 1,200+ AWS resources through natural language.

What AWS Labs Official Support Means

Not a hack. AWS built it. They maintain it. They're betting on natural language infrastructure.

The server:

  • Supports 1,200+ AWS resources (S3, Lambda, EC2, RDS, DynamoDB, VPC, etc.)

  • Outputs Infrastructure as Code templates for CI/CD pipelines

  • Integrates AWS Pricing API for cost estimates before deployment

  • Runs security scanning with Checkov automatically

  • Has read-only mode for safe production inspection

This is infrastructure management without the console or YAML.

What about Azure and GCP? Azure has an official Microsoft MCP server. GCP has community servers with official Google hosting docs. Both work. AWS just has more mature tooling—cost estimation, security scanning, IaC export. If you're on Azure or GCP, install their servers. Same workflow, slightly less polish.

The Security Layer

Here's what separates this from dangerous automation: built-in security scanning and read-only mode.

Every resource creation gets scanned. Before it deploys. If your S3 bucket is publicly accessible when it shouldn't be, the AI tells you before creating it.

For production accounts, enable read-only mode:

{
  "args": ["awslabs.ccapi-mcp-server@latest", "--readonly"]
}

Your AI can inspect infrastructure, list resources, check configurations—but can't modify anything. Safe for production audits.

Setup: One Config File

Installation via uvx:

{
  "mcpServers": {
    "awslabs.ccapi-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.ccapi-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-profile",
        "DEFAULT_TAGS": "enabled",
        "SECURITY_SCANNING": "enabled"
      }
    }
  }
}

Assumes you have AWS credentials configured (~/.aws/credentials). Uses your existing profiles. Respects your IAM permissions.

Required permissions: Cloud Control API actions (List, Get, Create, Update, Delete). Standard infrastructure management permissions.

Real Backend Scenario: Lambda API Deployment

You need a serverless API. API Gateway + Lambda + DynamoDB. The backend developer standard.

Old way:

  1. Write CloudFormation or Terraform

  2. Define API Gateway resources, methods, integrations

  3. Define Lambda function, runtime, memory, timeout

  4. Define IAM roles and policies

  5. Define DynamoDB table, indexes, capacity

  6. Test locally

  7. Deploy

  8. Debug IAM permission issues

  9. Fix and redeploy

Time: 2+ hours for a basic setup.

With AWS MCP:

You: "Create a serverless API for my application"
AI: [Via Cloud Control API MCP]
    "Creating:
     - API Gateway REST API
     - Lambda function (Python 3.11, 512MB)
     - DynamoDB table with on-demand capacity
     - IAM roles with least privilege
     
     Security scan: PASSED
     Estimated cost: $0.20/month (based on 10k requests)
     
     Want me to proceed?"

Time: 2 minutes from prompt to deployed infrastructure.

The AI generates the infrastructure code, scans it for security issues, estimates costs, and deploys through Cloud Control API. You review and approve.

Cost Estimation Before Deployment

This is the feature that saves teams real money.

Before your AI creates resources, it tells you what they'll cost. Monthly estimates. Based on your usage patterns if you provide them.

Example from AWS blog:

You: "Create an S3 bucket with versioning and encrypt it using a new KMS key"
AI: "S3 bucket: $0.023/GB/month
     KMS key: $1/month
     Estimated total: ~$1-5/month depending on storage
     
     Security scan: PASSED (encryption enabled, no public access)
     Proceed?"

You approve infrastructure knowing the cost. No surprise bills. No discovering your dev created a NAT Gateway that costs $32/month when you wanted $5.

Infrastructure as Code Output

The killer feature for teams with existing CI/CD: IaC template export.

Your AI creates infrastructure through natural language. But it also outputs the CloudFormation or Terraform code. You commit that to Git. Your CI/CD pipeline uses it for production deploys.

Best of both worlds. Natural language for speed. IaC for governance.

The Amazon Q CLI Integration

AWS built Amazon Q CLI specifically to work with MCP servers. It's a chat interface for your AWS account.

From the Cloud Financial Management blog:

You can:

q chat
> "Show me my EC2 instances sorted by cost"
> "Which S3 buckets have the most storage?"
> "Create a CloudWatch dashboard for my Lambda errors"

Everything through natural language. Amazon Q routes to the appropriate MCP server. Infrastructure management becomes a conversation.

Reality Check: AWS MCP

This won't make you a better architect. Won't design your VPC subnets. Won't optimize your Lambda memory settings. What it does: Removes the AWS console clicking and YAML writing when you know what you want.

You still need to:

  • Understand AWS services

  • Design proper architectures

  • Set appropriate IAM policies

  • Monitor costs

  • Handle security properly

Next Steps: Pick One and Install It Now

Here's the truth: you just spent 15 minutes reading this. Most people will do nothing.

Don't be most people.

Stop reading. Go install one.

4 MCPs Every Backend Dev Should Install Today

Your AI assistant helps with code, but it's blind to your actual systems. It hallucinates database schemas. Suggests MongoDB operators that don't exist. Writes CloudFormation that fails on deploy.

Here are 4 MCP servers that fix this:

  1. Postgres MCP - Your AI sees your actual database schema

  2. MongoDB MCP - Official MongoDB support for natural language queries

  3. Postman MCP - Manage collections and environments via AI

  4. AWS MCP - Infrastructure as code through natural language

1. Postgres MCP: No More Schema Guessing

The problem: You ask AI for a database query. It guesses. Column doesn't exist. You check pgAdmin, fix manually. Five minutes gone. Repeat 50 times daily.

Postgres MCP gives your AI direct database access. Three options:

Read-Only (Production Safe):

{
  "mcpServers": {
    "postgres": {
      "command": "docker",
      "args": ["run","-i","--rm","-e","POSTGRES_URL","mcp/postgres"],
      "env": {"POSTGRES_URL": "postgresql://host.docker.internal:5432/mydb"}
    }
  }
}

Full Access: CrystalDBA's Postgres MCP Pro with unrestricted/restricted modes.

Supabase: Their Remote MCP - paste URL, authenticate, done.

Real Impact: Finding slow queries. Old way: SSH, query pg_stat_statements, run EXPLAIN, guess index. 45 minutes. With MCP: "Show me the slowest queries" → AI identifies missing index → "Add it" → Done. 3 minutes.

Warning: Large schemas consume 10k+ tokens. Be specific with queries.

2. MongoDB MCP: Stop Writing Pipelines From Memory

The problem: Writing aggregation pipelines. Open docs, copy example, modify, test, fail, check syntax, realize $group comes before $match. Your AI suggests operators that don't exist.

MongoDB MCP Server - official from MongoDB Inc. 22 tools including aggregations, schema inspection, Atlas management.

Setup (Local):

{
  "mcpServers": {
    "MongoDB": {
      "command": "npx",
      "args": ["-y","mongodb-mcp-server","--connectionString",
               "mongodb://localhost:27017/myDatabase","--readOnly"]
    }
  }
}

For Atlas, add API credentials. Remove --readOnly for development databases.

Real Impact: Building analytics endpoint. Old way: copy pipeline example, modify, test in Compass, fix syntax, debug field names. 25 minutes per pipeline. With MCP: "Group orders by region, sum revenue, return top 5" → AI checks schema, generates correct pipeline. 45 seconds.

Your AI becomes a database analyst that knows your actual data structure.

3. Postman MCP: API Management Without Clicking

The problem: Building an endpoint. Create collection in Postman. Set environment variables. Write tests. Switch to code. Update API. Switch back. Update collection. 20 clicks for one command.

Postman MCP Server - official from Postman Labs. 38 base tools, 100+ in full mode.

Setup (Docker MCP Toolkit):

docker mcp client connect cursor -g
docker mcp server enable postman
# Add Postman API key in Docker MCP UI

Real Impact: Syncing OpenAPI specs from Django REST Framework. Old way: generate spec, export JSON, import to Postman, update collection, check endpoints. 15 minutes per API change. With MCP: "Sync my Django OpenAPI spec with Postman collection" → Done. 30 seconds.

Built-in tools: syncCollectionWithSpec and syncSpecWithCollection keep everything synchronized automatically.

4. AWS MCP: Infrastructure Without YAML

The problem: Need an S3 bucket with versioning, KMS encryption, CloudFront. Either click through console or write CloudFormation/Terraform. 30 minutes for something that should take 30 seconds.

AWS Cloud Control API MCP Server - official from AWS Labs. Manages 1,200+ AWS resources through natural language.

Features:

  • Outputs Infrastructure as Code templates

  • AWS Pricing API for cost estimates

  • Security scanning with Checkov

  • Read-only mode for production

Setup:

{
  "mcpServers": {
    "awslabs.ccapi-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.ccapi-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-profile",
        "SECURITY_SCANNING": "enabled"
      }
    }
  }
}

Add --readonly for production accounts.

Real Impact: Deploying serverless API (API Gateway + Lambda + DynamoDB). Old way: write CloudFormation, define resources, configure IAM, test, debug permissions. 2+ hours. With MCP: "Create a serverless API" → AI creates infrastructure, runs security scan, shows cost estimate ($0.20/month), deploys. 2 minutes.

Cost Protection: Before creating resources, AI shows monthly estimates. No surprise NAT Gateway bills.

CI/CD Ready: Outputs CloudFormation/Terraform code. Natural language for development, IaC for production pipelines.

Azure has official Microsoft MCP. GCP has community servers. Same workflow, slightly less features.

Install One Now

You just spent 5 minutes reading this. Most people will close the tab and do nothing.

Pick one. Install it. Use it today. Track the time saved.

The developers winning with AI aren't waiting for AGI. They're connecting their AI to their actual systems right now.


r/mcp • • Nov 28 '25

resource I stopped scrolling LinkedIn for hours. Here's how I find viral posts and engage automatically using AI.

49 Upvotes

Alright, I know the title sounds like clickbait, but hear me out. I've been doing LinkedIn outreach for about 2 years now, and I finally cracked a workflow that saves me 2-3 hours daily while actually increasing my engagement and inbound leads.

The problem with LinkedIn engagement is simple: it's a time vampire. You open the app to leave a few comments, and suddenly it's 90 minutes later, you've watched 14 videos about "hustle culture," and you've commented on maybe 5 posts. Sound familiar?

Here's the workflow I've been using for the past few months.

The Stack:

  • Claude AI (the chatbot from Anthropic - I use claude.ai)

  • ConnectSafely.ai (LinkedIn automation tool that integrates with Claude)

Step 1: Find Relevant Posts Without Opening LinkedIn

This is where it gets interesting. Instead of doom-scrolling my feed hoping to find good posts, I just ask Claude to search for posts in my niche.

For example, I work in B2B SaaS, so I'll say something like:

Claude uses ConnectSafely's integration to pull up recent posts with that keyword. I get back a list of posts with:

  • The author's name and headline

  • Post content preview

  • Engagement metrics (likes, comments)

  • Direct link

No LinkedIn tab open. No algorithm trying to distract me. Just the posts I actually care about.

Step 2: Check Out the Good Ones

Once I see a post that looks promising (high engagement, relevant topic, author I want to connect with), I can ask Claude to pull the full details.

It'll show me:

  • The complete post text

  • Who's commenting

  • The author's profile info

This lets me quickly decide if it's worth engaging with.

Step 3: React and Comment Without Leaving the Chat

Here's where the magic happens. I can tell Claude something like:

But here's the key - I don't just have Claude auto-generate some generic "Great post!" garbage. I'll either:

  1. Write my own comment and have Claude post it

  2. Ask Claude to draft something based on the post content, review it, tweak it, then post

For example, if someone posts about cold email being dead, I might say:

Claude writes it, I review it, make any changes, and then it posts directly through ConnectSafely.

The comment goes up. I never opened LinkedIn.

Step 4: Scale It (Without Being Spammy)

The temptation with any automation is to go crazy and engage with 500 posts per day. Don't do that. You'll get flagged, and honestly, it defeats the purpose.

What I do instead:

  • 10-15 thoughtful comments per day on highly relevant posts

  • Mix of reactions (likes, celebrates, etc.) on another 20-30 posts

  • Focus on accounts where my ideal clients hang out

The key word is thoughtful. Every comment should sound like something I'd actually write. I review every single one before it posts.

Why This Works for Inbound Leads

Here's what happened after 60 days of this:

  • My profile views increased 340%

  • Connection requests coming to me (not from me) went from ~5/week to ~25/week

  • I've had 3 discovery calls from people who said "I keep seeing your comments everywhere"

The psychology is simple: when you consistently show up with valuable takes on posts your target audience is reading, they start to notice you. Then they check your profile. Then they reach out.

If you want to try ConnectSafely, here's the link: https://connectsafely.ai

Happy to answer questions in the comments.


r/mcp • • Mar 12 '26

question mcp dead?

1 Upvotes

Woke up and everyone in X is debating if mcp is dead, did i miss anything? should i be concerned that i'm building an mcp?


r/mcp • • Sep 20 '25

discussion Convince me: why should a non-expert tech enthusiast start using Model Context Protocol?

0 Upvotes

Hey everyone,

I keep hearing about Model Context Protocol (MCP), but I’m not a developer or AI researcher, just a tech enthusiast who enjoys experimenting with new tools.

So here’s my challenge to you guys: Convince me why I should start using MCP. • What’s the practical value for someone who isn’t coding production apps? • Any “aha!” moments where it just clicked for you? • What are the coolest things you’ve built or automated with it? • Are there beginner-friendly ways to try MCP without getting overwhelmed?

I’m looking for the real-world reasons (and stories) that make MCP worth diving into. Bonus points if you can explain it like you would to a friend who’s curious but not super technical.

Peace ✌️

EDIT: Someone could help me to configure the basics for my needs? telegram user is: @apollo221


r/mcp • • Jan 14 '26

MCP is a fad and Anthropic knows it

0 Upvotes

Tom Bedor wrote a solid breakdown of why MCP doesn't hold up at scale:
https://tombedor.dev/mcp-is-a-fad/

Worth reading in full. The short version:

MCP was useful a year ago. It gave us a standard way to expose tools to agents. Every company shipped an MCP to check the AI strategy box. But as production systems scale, MCP becomes a liability.

The core problems:

  1. No execution guarantees. MCP has no concept of order. An e-commerce agent can call checkout() before add_to_cart(). You have to write fragile prompts/instructions and hope that the model follows them.

  2. Incoherency of tools. Tools work in isolation. Tools don't know what other tools exist. An agent with 30+ tools from different MCP servers has no guidance on which to use. OpenAI recommends under 20 tools. Most MCP go beyond this immediately.

  3. Token bloat. Tool schemas use massive context. Users report 30%+ of their context window consumed by tool descriptions. At scale, this is expensive and degrades output. As enterprises scale this to 100+ tools, this problem compounds, leading to hacky solutions like MetaMCP.

  4. Subprocess. With multi MCP users, each MCP server spawns a separate long lived process, chances of failure multiply, and maintenance cost compounds.

  5. Security. 492 servers found running without encryption or authentication. Multiple CVEs with 9.4+ CVSS scores. Prompt injection + tool call + data exfiltration attacks were reported within 6 months of release.

The blog makes a good point: MCP does a good job at schema serialization. The NxM problem it claims to solve was already addressed by LangChain, LiteLLM, and similar frameworks, without spawning subprocesses.

Emerging Patterns:

Anthropic shipping Claude Skills signals they know MCP isn't the answer. Solutions are emerging that enforce execution order, scope tools, without new processes.

The dominant pattern is enforcing state, order, and determinism, with agents interacting with services through explicit stages and legal transitions rather than free form calls. With many industry standard protocols, UAIP is one of the protocols (https://github.com/concierge-hq/uaip) that codifies this well.

Usecases for MCP: High-breadth use cases such as: Claude accessing local files, making git patches, simple integrations where minor failure is acceptable.

Usecases against MCP: Domain specific workflows. Usecases like ensuring an agent does not "call checkout before adding items to the cart" where agents must follow a series of steps to achieve an outcome. Production systems with high reliability expectations.

Finishing thoughts: MCP was too client oriented, the LLM is expected to be intelligent enough to know how server should be used. However this is not true, service owners are the right stakeholders to codify this context for the Agent. LLMs should not be allowed to free flow call remote tools in high stake scenarios. This implicit expectation of Client/LLM having context prevents MCP from being used in high stake reliable settings.

What do you think?


r/mcp • • Feb 05 '26

AI hired a human to save my ass while I was on a plane

0 Upvotes

there's been all this talk about AI agents hiring humans to do stuff. sounds cool but also kinda dystopian, and honestly most of these services are just trolls or make you pay in crypto or whatever, kinda scammy

anyway I found one that actually works (Duckbill)

today I jumped on a flight from Madrid to Boston and realized I forgot gloves. I'm already in the air, so I have Claude Code get me a pair sent to the hotel via the MCP. it bought them on Instacart and got an actual human to call the hotel to make sure they'd hold the package.

all while I'm literally on the plane lol

gloves were there when I landed. wild


r/mcp • • Sep 23 '26

Built an MCP server. Can't get it past company IT

2 Upvotes

I'm building an MCP server for knowledge search. Turns out getting it in front of actual users at companies is harder than building the thing.

Tried to submit to Claude's official directory. Needs a Team org account, 2-seat minimum. I'm one person. So ~40 euros/month for a seat I'll never use, just to be allowed to submit: I tried once before summer. Took them 3 months to tell me they'd changed the submission process and I had to start over.

But... that's not even the real problem. The real one: plenty of companies block third-party MCP servers outright at the IT/security level. Doesn't matter if you're listed anywhere, no exceptions.

Anyone else running into this? What's actually worked to get through?


r/mcp • • Mar 12 '26

resource MCP is not dead! Let me explain.

Thumbnail ricciuti.me
0 Upvotes

I'm tired of everybody claiming MCP is dead... I put my thoughts in words here!


r/mcp • • Nov 25 '25

Satoshi Nakamoto and MCP

Post image
0 Upvotes

r/mcp • • May 12 '25

We’re building Plast.ai, a hosted platform that 10x’s the MCP experience.

0 Upvotes

Hey everyone! We’ve been using mcp servers in our day to day work, but we’ve always encountered a variety of challenges:
- securely connecting servers

  • knowing what tools are executing with

  • bringing in the right context from external sources

So we decided to build a hosted platform to securely manage mcp servers under the hood and 10x the UX of using integrations.

Here’s a demo showing how Plast:

  • Finds some coffee chats planned in my Notion

  • Uses Apollo.io to find company office locations

  • Finds nearby coffee shops to the offices

  • Creates calendar invites in GCalendar

Would love for you to give it a try and to hear your thoughts and feedback!


r/mcp • • Aug 01 '25

If You're an MCP Company You're NGMI

Thumbnail
lirantal.com
1 Upvotes

I guess this is a bit controversial but I wanted to share my thoughts given all the hype around AI and MCP and calls for a "bubble" in the current economy.

If you have a different perspective please share, we can all learn from broader experience.


r/mcp • • Jun 02 '26

showcase My whole team works in Claude and ChatGPT now. Sharing the output is still a mess.

1 Upvotes

Everyone I work with has gone all-in on LLMs. They run deep research, dig through data, write up customer calls, put together competitive teardowns and project updates. The actual work is good.

Then they go to share it, and it falls apart. Usually one of three ways:

  • paste the whole thing into a Google Doc and watch the formatting die

  • get the agent to spit out some HTML, throw it on Vercel, and now there's a random page sitting there public that nobody locked down

  • screenshot the chat and send that around

So the work is solid and the thing people actually see is junk. That gap bugged me enough to build something.

It's called Superfact. It's an MCP server, so it runs inside whatever you're already in. You finish something worth sharing, tell your assistant to publish it, and a few seconds later you get a real web page with its own link. You don't mess with layout. It reads what you've got and picks the format that fits, a research brief, a decision memo, a progress log, or it builds a custom layout when nothing standard works. No model runs when the page renders, so it's fast and it looks the same every time.

You decide who sees it. A page can be fully public, locked behind a password, or kept private to just you. None of it ever gets indexed, so it won't turn up in Google.

It works wherever MCP does: Claude (desktop and web), Claude Code, Cursor, VS Code, Codex, and ChatGPT in developer mode. Connect it once and it's there.

Full disclosure, this is mine. I'm posting here because you're the people most likely to actually push on it. What I want to know: do you hit this same problem, and how are you handling it today? And if you try it, does publishing straight from your chat actually hold up, or does it break somewhere? Tell me where it's rough.

https://superfact.ai


r/mcp • • Aug 05 '25

Can someone explain to me what an MCP is?

0 Upvotes

What’s an mcp used for? Is it the same thing as an agent? Not trying to sound dumb. Just trying to understand the hype


r/mcp • • 26d ago

showcase I got tired of setting up MCP servers on every laptop, so I built a gateway for it

0 Upvotes

At work, every person was running their own MCP servers locally. Same servers, same API keys, copied to everyone’s machine.

So I built an open-source gateway. You set up the servers once, and everyone connects to one URL.

What it does:

  • Runs the MCP servers for you, including stdio ones

  • Keeps the API keys on the gateway, never on people’s laptops

  • Lets you choose who can use which tools

  • Shows you which tool was called, by whom, and what it answered

  • Can hide hundreds of tools behind a simple “search” tool, so your context doesn’t fill up

It’s free (Apache-2.0) and runs with one Docker command.

https://github.com/eliasbiondo/antirion

Still early, so feedback is very welcome. How are you sharing MCP servers with your team today?


r/mcp • • Apr 01 '25

MCP Router Launched 🚀 | Simple MCP Management, Auth & Logs in One Place

1 Upvotes

Hey MCP fans!

We're thrilled to announce the launch of MCP Router, a powerful new app designed to simplify managing your MCP servers for your LLM applications.

What is MCP Router?
MCP Router enables you to manage all your MCP servers in one convenient spot—no more hassle juggling individual servers for each application. Key features include:

✅ One-click MCP server installation & management
✅ Automatic logging & intuitive log analysis
✅ Secure, token-based app authentication 🎉

Collaborations & Feedback Welcome!
Interested in collaborating or have feedback? Reach out via X/Twitter

Free Download Now: https://github.com/mcp-router/mcp-router/releases/

Follow us: https://x.com/mcp_router

Our Website: https://mcp-router.net


r/mcp • • Jul 18 '25

It’s Official! We Are Now Included in Anthropic’s Model Context Protocol Servers Repo!

1 Upvotes

We’re thrilled to share a milestone that’s been months in the making since our launch of NetMind MCP Hub: our server was just merged into Anthropic’s official Model Context Protocol (MCP) Servers repository. This means our implementation now sits alongside the community’s most trusted reference servers, ready for developers everywhere to clone, fork, and build upon!

https://blog.netmind.ai/article/It’s_Official!_We_Are_Now_Included_in_Anthropic’s_Model_Context_Protocol_Servers_Repo!?utm_source=reddit&utm_medium=reddit&utm_campaign=blog

About NetMind.AI:
At NetMind.AI we believe that AI should be for the people and for the betterment of Humanity. We work towards developing AI products that make a positive impact on humanity in an ethical way, whilst keeping the end user's interest at heart.


r/mcp • • Sep 10 '26

I forgot what MCP stands for... WRONG answers only

1 Upvotes

"Remind" me please!


r/mcp • • Aug 03 '25

My company wanted to use MCP servers but IT shut it down. Here's how we solved it.

32 Upvotes

Disclaimer: I'm converting the solution I created at my company into a product.

I work at a company where we're trying to use AI tools more effectively. We wanted to give our teams access to MCP servers - GitHub for code, Slack for communications, databases for analytics. But we hit some real problems.

First, I set up MCP servers on my laptop. Worked great. Then I tried to roll it out to the team.

IT took one look at my claude_desktop_config.json and said no. Fair point - I was asking people to put GitHub tokens, database passwords, and AWS keys in plaintext files. On every laptop. They showed me what could go wrong if one laptop got compromised. It wasn't pretty.

Even when we tried a pilot with a few technical folks, it didn't go well. I spent hours helping our marketing team edit JSON files. They're smart people, but JSON syntax errors aren't their thing. One misplaced comma and Claude just... doesn't work.

Then I did the math on running separate MCP server instances for everyone. The infrastructure costs alone would have killed the project.

Building a Different Approach

That's when I started working on Oppie. The idea was simple: what if credentials never touched anyone's laptop?

Here's what we built:

Before (on every laptop):

{
  "github": {
    "command": "npx /server-github",
    "env": { "GITHUB_TOKEN": "ghp_xxxxx" }
  },
  "slack": {
    "command": "npx /server-slack",
    "env": { "SLACK_TOKEN": "xoxb-xxxxx" }
  }
  // ... more servers with more secrets
}

After (on every laptop):

{
  "oppie": {
    "command": "oppie-bridge",
    "args": ["--token", "OPPIE_TOKEN"]
  }
}

The credentials? They live in Vaults & DB in our cloud, encrypted. IT was much happier with this.

How It Actually Works

We run a Kubernetes cluster with all the MCP servers. Each one is isolated - can't talk to the others, can't access internal networks. The oppie-bridge on your laptop just forwards requests to the right server.

Your laptop → oppie-bridge → Our gateway → MCP server (with credentials injected)

The gateway handles:

  • Credential injection (servers get tokens at runtime)

  • Audit logging (IT can see who's using what)

  • Caching (turns out this saves a ton of tokens)

  • Access control (who can use which servers)

Making It Usable

The technical solution was only half the battle. Our non-technical users still couldn't set it up.

So we built a desktop app. Now the setup is:

  1. Download Oppie Desktop

  2. Sign in with your work account

  3. Click "Set up Claude" (or Cursor, or whatever)

  4. It works

No JSON editing. No command line. It just configures everything automatically.

What Surprised Us

We expected the security benefits. What we didn't expect:

  • MCP Server resource footprint dropped 95% - The gateway caches tool definitions

  • Much faster responses - <50ms even with 150+ tools

  • Way cheaper - One cluster for everyone vs. individual setups

  • IT actually likes it - They can see all API usage in one place

Some real numbers from our setup:

  • 9000+ users across engineering, marketing, and ops

  • 300+ different MCP servers

  • ~400/month in infrastructure costs (was looking at 2000+)

  • 1 minute average setup time (was 2+ hours)

Current Status

What works well:

  • Security model (IT approved!)

  • Easy setup for non-technical users

  • Performance and cost savings

  • Audit trails for compliance

What we're still working on:

  • Rather than long lived token for the client, we are working on OAuth based token or some kind of fingerprinting, which will be more secure.

  • Smart tool selection (still loads everything)

  • More MCP servers in our registry

  • Better team management features

Try It

If you're hitting similar problems:

  • oppie.ai - Free for everyone to use (LIMITED TIME!)

  • Desktop app - For easy setup

  • Self-host with your infra if you prefer (Needs Enterprise License)

Questions I Can Answer

  • How we got IT buy-in (happy to share our security docs)

  • Actual cost breakdowns

  • Migration process from local setups

  • Which MCP servers work best

  • Setup for specific AI tools (Claude, Cursor, etc.)

Started building this because we needed it. Turns out we weren't the only ones stuck between "MCP servers are powerful" and "MCP servers are a security/UX nightmare."

Anyone else trying to roll out MCP servers at scale? What problems are you hitting?


r/mcp • • Mar 27 '26

server MCP is the architectural fix for LLM hallucinations — not just a "connect your tools" feature

Thumbnail rivetedinc.com
6 Upvotes

Hot take: people talk about MCP like it's a convenience feature (Claude can read your files now!) but the more interesting angle is that it makes hallucinations structurally impossible for anything in scope.

Came across LegalMCP recently, open-source MCP server with 18 tools across CourtListener, Clio, and PACER. Used it to explain MCP to a friend who's an AI compliance attorney because it's such a clean example.

The key insight: when the AI is configured to call search_case_law for case research, it can't hallucinate a citation. It either finds the case in the database or it doesn't. The fabrication pathway is closed.

This is different from RAG in an important way, MCP gives the model a controlled, enumerable set of tools with defined inputs and outputs. Every call is a discrete logged event. You can audit exactly what the system touched and what it returned. That's not just good for reliability, it's what AI governance actually looks like in practice.

Wrote a longer post on this: https://rivetedinc.com/blog/mcp-grounds-llms-in-real-data

The tl;dr: if you're building AI products where accuracy matters, MCP isn't optional infrastructure. It's the thing that makes your system verifiable.


r/mcp • • Apr 25 '26

Someone's agent was calling my MCP server every 30 minutes to make routing decisions. That's when I understood what I was actually building.

2 Upvotes

I started Tickerr.ai a few weeks ago as a simple "is Claude down?" tracker. Because many times while building, I was not sure whether my code is not working or LLM provider is having an issue. It was a simple tracking of HTTP pings, status pages checks and incident history along with some models API inference checks. I had also created an MCP server on top of it.

Recently, when I looked at the MCP usage logs I saw something that I didn't expect at all: someone was making simultaneous back to back calls every 30 mins. Always the same two tools: "get_tool_status" + "compare_pricing".

Someone had wired Tickerr into their agent loop. Before every API call, their agent was checking which models are up and what they cost and then routing accordingly.

I hadn't built it for that. But it made complete sense. So I rebuilt around it.

What Tickerr does now:

- Live status for 90+ AI tools, checked every 5 min via HTTP probes.

- Real API inference monitoring - authenticated calls to 17 models across 8 providers (Anthropic, OpenAI, Google, Groq, Mistral, Cerebras, xAI, OpenRouter), measuring TTFT and tokens/sec. This catches model-layer failures that HTTP pings miss entirely. In 30 confirmed outages, HTTP pings only caught ~57% of them. The other ~43% were auth or model-layer failures - invisible to any ping-based monitor.

- 300+ models with live pricing - input/output per million tokens, updated daily, pricing changes are tracked, not just current state.

- 1,000+ incidents with full timelines - several detected 10 to 40 minutes before official status pages updated.

For builders using agents:

claude mcp add tickerr --transport http --url https://tickerr.ai/mcp

The "get_model_performance" tool returns p50/p95 TTFT per model -so your agent can ask "which model is fastest right now" not just "which model is up."

No login, no paywall. If you're building agents that make API calls across multiple providers, curious whether this is useful or what's missing.


r/mcp • • May 12 '25

discussion We now offer 2000+ MCP out of the box + local tools. Now what?

1 Upvotes

Hi everyone,

We've been experimenting with MCP for months now, and since last Friday, we have given access to our users to more than 2000+ remote MCPs out of the box, along with local tools (Mail, Calendar, Notes, Finder). But it really feels like the beginning of the journey.

  1. AI+MCPs are inconsistent in how they behave. Asking simple tasks like "check my calendar and send me an email with a top-level brief of my day" is really hit or miss.

  2. Counterintuitively, smaller models perform better with MCPs; they are just quicker. (My favorite so far is Gemini 2.0 Flash Lite.)

  3. Debugging is a pain. Users shouldn’t have to debug anyway, but honestly, "hiding" the API calls means users have no idea why things don’t work. However, we don’t want to become Postman!

  4. If you don’t properly ground the MCP request, it takes 2 to 3 API calls to do simple things.

We know this is only the beginning, and we need to implement many things in the background to make it work magically (and consistently!). I was wondering what experiences others have had and if there are any best practices we should implement.

---

Who we are: https://alterhq.com/

Demo of our 2000 MCP integration (full video): https://www.youtube.com/watch?v=8Cjc_LwuFkU


r/mcp • • Jun 10 '25

Best Model Context Protocol (MCP) Servers in 2025 (Based on GitHub Stars)

1 Upvotes

MCP is quickly becoming a key piece for anyone building LLM agents that need real-time, structured context from external tools.

A team put together this list ranking of the most popular Model Context Protocol (MCP) servers (as of June 2025) and flagged how people are shipping these MCP servers without security or access controls, a big problem since if your agent can read prod logs or push to GitHub, it can also go rogue.

Would love to hear how folks are approaching the idea of security when it comes to agentic systems!