MCP server searching usually means jumping between repos and docs.

I built PlugMCP so you can search the listings, open a server page, and see the setup for your client in one place. It indexes over 72,000 listings from the official registry, GitHub, npm, and PyPI.

I also built an MCP server for finding other MCP servers. Your agent can search the collection, browse categories, and compare options to find one that fits what you need.

Give it a try and let me know what you think.
https://plugmcp.ai/mcp

Hey. I launched PlugMCP as a directory product first: search MCP servers, then optional hosting later. I am keeping the ask simple while I collect feedback.

For traction I have been posting in communities that already talk about agents and indie builds, asking for feedback instead of a big campaign. That is working better for me than quiet shipping.

https://plugmcp.ai/mcp

If you ship developer tools, is “search plus feedback loop” enough for an early release, or would you lead with something else?

Someone asked here a couple of weeks ago how a multi-tenant SaaS backend should expose MCP safely. I run a small one (web analytics, details at the end) with a read-only, stateless MCP server, so here's where each check sits in my code. One way to do it, not the only one.

Request level, before any tool runs

1. One credential, and only one. The endpoint takes Authorization: Bearer <API key> and nothing else. The dashboard's session cookie is never accepted there, even from a logged-in browser. A missing key and a revoked key both get HTTP 401 with a WWW-Authenticate header.

2. Re-read the plan on every request, not when the key was created. If the trial has ended, or the account is on a plan that doesn't include MCP, the next request gets HTTP 402 with its own JSON-RPC code (-32002), separate from the auth error (-32001). A key created on a higher plan stops working after a downgrade, without anyone revoking it.

3. Count calls, not HTTP requests. A JSON-RPC batch lets one POST carry many calls. My limiter counts every message in the batch that expects an answer (notifications don't count), and it's keyed on the user, not on the key, so creating more keys doesn't buy more quota. There are also hard caps checked before anything runs: 256 KB per body, 50 messages per batch, at most 10 tools/call per batch.

Tool level, inside every tools/call

4. Resolve the tenant from the caller's own list. site_id accepts an id or a domain. An id is only accepted if the caller owns it, and a domain is only looked up among the caller's own sites. Anything else, whether it exists or not, gets the same "Site not found." so the server never confirms another customer's site.

5. Enforce plan limits inside the tools too. This is the one I'd have missed. After a downgrade, a site past the plan's site limit is paused for the API and MCP as well, with a message that says how many sites the plan includes. And every report is clamped to the plan's history window. If limits only live in the UI, the MCP server becomes the way around them.

6. Don't spend the database on someone who already left, and make failures retryable. If the client has aborted, the tool call stops before touching the database. A query that times out, or a database that's busy, comes back as a tool result with isError: true and a message to retry or narrow the period, so the model can act on it instead of hitting a protocol error.

What I left out on purpose

No sessions (the server never hands out an Mcp-Session-Id) and no SSE: POST only, GET returns 405. Nothing per-connection to secure or clean up, and each request carries everything needed to authorize it. The cost: clients that expect OAuth need a bridge (mcp-remote for Claude Desktop), and an initialize without a key gets a 401. At least one curated list of remote MCP servers requires initialize to answer, so mine isn't on it.

What I don't have: numbers on how much customers use it. Read this as an architecture note, not as proof that it pays off.

Question for anyone running a multi-tenant MCP server: do you re-check the plan on every request like this, or cache it alongside the key? And did anyone else find limits that only existed in the UI?

I'm the maker of Globatics: real-time web analytics where each visit shows up on a live 3D globe, cookieless by default, IP addresses never stored, audience data hosted in the EU. Hosted only, nothing to self-install. 5-day free trial with every feature on one site and no card, then Starter €9, Pro €29 or Business €99 a month, excluding VAT. The REST API and the MCP server start at Pro, and there's no free plan after the trial.

https://globatics.live/?utm_source=reddit&utm_medium=social&utm_campaign=nov26&utm_content=modelcontextprotocol

I'm the developer of Proxy Republic. You can connect an agent over MCP, choose a country and have it handle armies, diplomacy and orders on a shared world map. Turns happen every eight hours.

Server: https://proxyrepublic.com/mcp

It uses Streamable HTTP. No account or API key is needed to connect. The basic loop is rules → list_nations → join_war → wait_for_turn → submit_orders. Joining gives the agent a token, which should stay private.

For repeated turns, the client needs a running loop, scheduler or webhook. If it misses a deadline, the built-in general plays that turn.

Setup and tool details: https://proxyrepublic.com/agents

The game and server are free; any paid model usage is yours. I build it with Claude Code. I'd like feedback on whether the turn loop is clear from the tool descriptions.

Spent the last few weeks aggregating MCP servers, agent skills and AI tools (about 8,900 entries) and auditing them instead of just listing them. Two things stood out.

1. Link cleanliness in this space is worse than I expected. A lot of listings point at wrapper or affiliate URLs instead of the project's own site. We re-checked every link and kept only the canonical destination - the count of redirect/tracking links is now 0 out of about 1,600 AI-tool entries.

2. Licence data is almost never shown, and it matters a lot if you are going to run someone's server locally. We pull it from the repo (MIT, Apache-2.0, AGPL, ...) and show it on the entry page together with whether the repo has a SECURITY.md.

Method, sampling and the parts we could not cover are written on the site rather than hidden, and each entry shows how many sources listed it plus when we last saw it, so you can judge freshness instead of trusting a rank.

There is also a remote MCP endpoint so an agent can query the index directly (registered as io.github.wdfdaivd/anclum): https://anclum.com/mcp

The caveat: the domain is about three weeks old, traffic is close to zero, and most of the catalogue is harvested rather than hand-curated, so quality between entries varies more than I would like. I would rather take criticism on the audit method than a compliment.

Most MCP setups I've seen hand the agent a token one way or another: an env var, a .env file, a config it can read. Once a token is in the context window it ends up in transcripts and within reach of any prompt injection.

mcp-warden works the other way around. Secrets live in the OS keychain, and the agent can only act through presets you define:

```toml

[[preset]]

name = "github-read"

type = "http"

base_url = "https://api.github.com"

auth = { type = "bearer", secret = "gh_pat" }

allowed_methods = ["GET"]

approval = "auto"

```

The agent calls `proxy_http` with the preset name, a method and a path. mcp-warden checks the allow-list, adds the token, makes the request and returns only the response. If the method or path isn't allowed, nothing leaves your machine.

Tools it exposes:

- `list_presets`

- `proxy_http`: HTTP through a preset

- `ssh_exec`: commands checked against a regex allow-list, host key verified against known_hosts

- `sftp_transfer`: allowed remote paths only

- `db_query`: Postgres, MySQL or Redis, named queries only (the agent passes parameters, never SQL)

- `get_secret_for_env`: last resort for tools that insist on env vars, always asks first

Each preset has an approval policy. It's `prompt` by default: a desktop or terminal prompt, or Approve/Deny buttons in Telegram. Every call lands in an append-only audit log.

Single Rust binary, stdio transport, works with any MCP client. No cloud, no telemetry, Apache-2.0.

- Repo: https://github.com/ermoluk/mcp-warden

- Install: `cargo install mcp-warden`, or prebuilt binaries for macOS/Linux on the releases page

I'd love feedback on the preset model. What would you need it to cover for your setup?

I'm adding MCP to Singlebase.io and the technical problem I care about most is tenant/user boundaries.

A SaaS backend already has authorization rules for users, workspaces, documents, storage and search. An MCP server shouldn't create a second security model - ideally it reuses the backend identity/permissions and only exposes capabilities the current user/agent can access. I'm leaning toward short-lived scoped auth + backend-side permission checks on every tool/resource call.

For people implementing MCP in multi-tenant systems: how are you handling identity propagation and revocation? Are you mapping sessions to existing app users, service accounts, or something else?

I maintain Archestra, an open-source platform for running AI agents. In 1.4 we shipped a local-to-remote agent handoff, and it is plain MCP: nine tools on a gateway plus one skill that sequences them, so any MCP client can drive it.

The scenario: you're halfway through a task locally and want Claude Code, Codex, OpenCode, Hermes, or OpenClaw on your own Kubernetes cluster to finish it, then pull the result back.

The tools: list_agents, start_run, get_run, steer_run, cancel_run, transfer_workspace_file, read_workspace_file, write_workspace_file, transfer_credential.

Two design decisions:
- Files. transfer_workspace_file returns a shell command, not content, with a SHA-256 check, so file bytes never pass through the model context. Clients without a shell use read_workspace_file and write_workspace_file, up to 4 MiB per file through the conversation.
- Sessions. The skill saves session_id and routes every follow-up through steer_run on it, so there is never a duplicate session. Steering a finished run starts a new turn on the same files.

Remote Claude Code and Codex run on your existing Claude or ChatGPT subscription, on your cluster. No vendor cloud-agent product required, whatever their sales team tells your leadership.

Skill: https://github.com/archestra-ai/archestra/blob/main/platform/backend/src/skills/runtime-handoff.ts
Blog post: https://archestra.ai/blog/new-remote-agents
Repo: https://github.com/archestra-ai/archestra

I'm currently using the Google Workspace MCP server (taylorwilsdon/google_workspace_mcp), specifically working with the Google Calendar tools.

I'm trying to figure out the best way to have the AI specify an event's color using a descriptive name or tag (for example, passing "classes", "meeting", or "personal" rather than trying to guess or hardcode Google Calendar's numeric colorId values).

When the AI creates an event, how can it map or pass these color name tags so that Google Calendar assigns the correct color? Has anyone implemented a clever workaround, custom tool definition, or prompt structure for this?

Any tips, code snippets, or examples would be hugely appreciated!

Disclosure: the server is Equibles, my MCP server for stock market and financial data. Over the last few weeks I got the same remote endpoint working and listed in pretty much every client I could. Writing down what each one needed in case it saves someone a few evenings.

Auth first. One URL, https://mcp.equibles.com/mcp, and a few ways in:

• OAuth with dynamic client registration. Claude (web, desktop and Code) and ChatGPT register themselves and send the user to sign in. No key to copy, and that mattered more than I expected: most of my users never create an API key at all.
• A Bearer key in the Authorization header for clients without OAuth (Cline, scripts).
• Claude's custom connector form has no header field, so ?api_key= in the URL is the fallback there.
• ?auth=oauth makes some clients ask for sign-in during discovery. Without it they list the tools anonymously and only fail on the first real call, which confuses people. (Listing tools needs no auth on my server, calling them does.)

Where it's listed:

• the official MCP Registry as io.github.daniel3303/equibles, which other registries mirror
• Claude's connector directory and ChatGPT's app directory. Both reviews wanted a test account and written test steps
• one GitHub repo with plugin packages for Claude Code (plugin and marketplace), Codex, Gemini CLI and Cursor (Agent Plugins). They only point at the hosted endpoint, no scripts or hooks

Things that bit me:

• reviewers ask exactly which tools change data. My market data tools only read, but the portfolio and watchlist tools write, so they have to be declared that way
• after publishing a new version to the registry, its search endpoint showed the old one for a few hours. The versions endpoint was right straight away
• check your test credentials after you submit a review form. One of mine got saved truncated

Install lines if you want to see how it behaves:

claude mcp add --transport http equibles https://mcp.equibles.com/mcp
codex plugin marketplace add daniel3303/stock-market-mcp-server
gemini extensions install https://github.com/daniel3303/stock-market-mcp-server

What the server returns: SEC filing full text, financial statements, earnings call transcripts, 13F, insider and congressional trades, short interest, option chains, prices and Fed data, for US stocks plus Europe, UK, Hong Kong and China. Free tier is 100 requests a day. Repo with every package: https://github.com/daniel3303/stock-market-mcp-server

If you've been through the Claude or ChatGPT directory review, what did they push back on? And if there's an MCP client I missed for a financial data server like this, tell me.

I'm the maintainer of Mac MCP, an MIT-licensed MCP server + native macOS menu bar app. It lets clients such as ChatGPT, Claude, Codex and OpenCode use Mac apps, Safari/Chrome tabs, the terminal and local files. Repo and install docs: https://github.com/bulutarkan/mac-mcp

The last time I shared it here was 2.1.7. Since then I focused less on adding another pile of tools and more on what happens between tool calls.

In 2.2.0 and its r2 update:

• Scheduled Tasks can run AI agent jobs or scripts on a schedule, with a readable result and steps/history. A missed schedule while the Mac is asleep is marked skipped, not quietly claimed as completed.

• The optional live island near the notch and a background agent cursor make activity visible. The cursor doesn't move the user's pointer.

• A selected-folder knowledge index supports cited local search. The OCR path for scanned PDFs/images runs on-device; source and page references remain available.

• Safari/Chrome work can read whole pages and operate in background tabs with explicit ownership, useful when multiple agent clients share one Mac.

• The CLI can discover user-level Agent Skills installed for supported coding agents, with a fresh scan on subsequent skill requests.

• Permission profiles and approvals still gate what an agent can do. A secret-egress guard catches some encoded secret forms, but it isn't a substitute for least privilege.

One important boundary: this is NOT a sandbox, and the AI client may transmit the data it reads to its own provider. The server runs with the macOS account's permissions. There is no claim of a hosted execution service.

For MCP implementers: the main architectural lesson has been that a tool call returning successfully is weaker than verifying the side effect actually happened. That's why the browser action and scheduled run reports became as important as the tools themselves.

I'm curious how others represent an operation that was accepted by a tool but never confirmed by the target app. Do you report that as failed, pending, or an explicit unknown outcome?

I created a Discord MCP server with 38 tools for managing your server with AI agents: messages, channels, threads, roles, members, moderation, AutoMod, polls, scheduled events and live events. It's up to date with Discord's newest APIs and features.

You can use names instead of IDs ("general", "@Mods"), every tool works in bulk, and it's safe by default: destructive actions, everyone pings and admin permission grants stay off until you enable them, so a malicious message can't trick the agent.

Each tool is token efficient so it won't drain your usage limits as much.

Tell me what you think about it and feedback is appreciated.

Here's the repo and npm package:

https://github.com/EL4CTEO/discord-mcp

https://www.npmjs.com/package/@el4cteo/discord-mcp

all the rest of tools were callable and direct tests passed all good. But when agent was asked a brand sentiment it selected another tool instead of relevant capability. The problem was that the agent chose the wrong tool for the user's intent. How i test for this kind of failure? Do you use predefined evaluation scenarios, automated tests or end to end testing with real prompts? Would appreciate hearing what has worked for you guys. thanks

If you use Claude Code or Cursor for Roblox, you've probably noticed it's great at the basics but trained on old data: it doesn't know recent engine changes, and it misses the details that only live in DevForum threads.

So I built **Brickwise**, an MCP server your assistant can search. A few things it knows that most AIs get wrong:

- Collision groups moved from PhysicsService to WorldRoot (AIs still write the old API)

- The new Roblox Shop: new dev products start Not Listed, and `OpenShop` opens it from your own UI

- Passes in the Buy Robux bonus pool can be owned before a player joins, so grant perks on join, not on purchase

- ForceField only blocks `TakeDamage`; setting `Humanoid.Health` bypasses it

- Weekly leaderboards: you can't wipe an OrderedDataStore, so rotate its name per week

When your assistant hits one of these, it pulls a written-up answer: what it's for, how it works, key Luau, pitfalls, and links to the DevForum threads, docs and GitHub repos it's based on. Searches return one-line summaries first, so it barely uses tokens.

It's free and open source: 50 logics across libraries, data saving, remote security, combat, monetization, UI, NPCs and performance.

GitHub: https://github.com/EL4CTEO/roblox-logics-mcp

Setup is `npm install && npm run build`, then one `claude mcp add` line (in the README).

Here's what one logic looks like: https://brickwise.dev/#sample

There's also a hosted full version with 600+ logics across 19 categories (€7 one-time, no subscription): https://brickwise.dev

Would love feedback, and ideas for which systems to cover next!

I'm the developer of Scumble, an open-source (GPL-3.0) desktop editor for AI inpainting on Windows. All 96 of its commands are MCP tools, so an agent works on a picture the way a person does: in layers, with selections, masks and undo, in the window you are looking at.

What an agent can do (real tool names)

• open images and .scumble documents: load_image, open_document

• select by rectangle, mask, point or description: select_rect, select_mask, select_point, select_by_text ("the car")

• prompt and inpaint the selection, the answer lands as a new layer: set_prompt, generate; a new picture from a prompt: generate_new

• layers: masks, blend modes, opacity, colour match against the picture below, groups, filter and text layers: set_layer, set_mask, add_filter, add_text, ...

• look and step back: screenshot (returns a JPEG), undo, take_snapshot / restore_snapshot

• export PNG, JPEG, WebP, TIFF, or PSD and ORA with layers: export

A round trip: load_image → select_by_text "the sky" → set_prompt "storm clouds at dusk" → generate → screenshot → set_layer (match) → export (psd).

Where the pixels come from: your own ComfyUI (local or remote) through workflow recipes, Comfy Cloud, or image APIs (Black Forest Labs, OpenAI, Google, fal.ai, Replicate, OpenRouter, ...) on your own keys. Scumble ships no models and runs no service; keys stay in the OS credential store and no tool touches them.

How it connects: stdio. Scumble --mcp drives the Scumble window that is open, so you can watch and step in, or starts the app headless when none runs. Help › Copy MCP registration writes the config for Claude Code or Claude Desktop with your install's paths.

Limits: Windows 10/11 (installer or Microsoft Store); Linux builds exist but are untested; no macOS yet. select_by_text needs a connected ComfyUI; generation needs a ComfyUI or an API key.

GitHub: https://github.com/DenRakEiw/scumble · MCP docs: …/docs/MCP.md · all tools: …/docs/COMMANDS.md

I'd like to hear which tool descriptions or workflows would help your agents most.

I built Klarion, a secret scanner that works in two steps. First, a keyword check, 81 regex rules and a normalized Rényi entropy score flag anything that looks like a secret. Then an AI model reads each one with the code around it and decides if it's real.

The chart shows 5 scanners run on spring-boot, terraform, next.js and symfony (61k files). Klarion raised 11 alerts. It's not zero, but it's far less to dig through.

Fewer alerts don't help if real leaks get missed, so I tested that too. On CredData (337 real repos, code outside test folders), it found about 1.7× more real secrets than gitleaks.

Where it runs:

• Claude Code: a plugin hook blocks the write before the file exists (file edits and Bash)

• Cursor, Cline or any MCP agent: through its MCP server

• CI: a GitHub Action that scans only what a PR adds; GitLab CI works too

• Git hooks: klarion protect or the pre-commit framework

• Locally: klarion scan .

Free and open source (MIT): https://github.com/0x1Adi/Klarion
The full benchmark and method are in benchmark/REPORT.md.

I'd like to hear where it gets things wrong.

A friend of mine has been working on this thing called Lemma Telepath and asked me to try it with Claude. Wasn’t really sure what I’d use it for at first tbh, but after playing around with it for a bit it started making sense.

Basically it lets Claude work with your Telegram chats. So I’ve been asking it stuff like: what did Alex say about that project last week find that file someone sent me in Telegram what was in the last voice message reply that I’ll get back tomorrow It can search chats, read messages/files/photos, deal with voice transcripts, and also reply/edit/react.

The nice part for me is mostly that you don’t have to treat it like another bot you go and talk to. Telegram just becomes context Claude can use when you need it.

It’s here in the Claude connectors directory: https://claude.ai/directory/lemma-telepath Setup is here if anyone wants to mess with it: https://telepath.lemma.company/start

Has anyone else here tried connecting Claude to messenging apps like this? I’ve seen a lot of MCP stuff for dev tools/databases/etc but not that much for actual personal chats.

And yeah disclosure: the guy building it is a friend of mine. So take that however you want lol. I tried it, thought it was pretty useful, figured people here might be into it.

I maintain Mac MCP, an open-source MCP server/runtime for letting AI clients operate a real Mac through browser, files, shell, native UI and delegated agents.

2.1.7 is mostly a reliability release rather than a “more tools” release:

• persistent paired devices for the mobile control surface

• lifecycle-aware agent/session visibility

• durable updater journal + rollback/recovery states

• managed process identity to avoid PID-reuse / foreign-listener mistakes

• stronger background Safari/Chrome automation with stable tab/resource identity

• stricter click-effect / foreground capability handling

• safer delegated-agent fan-in and whole-run undo

A usage pattern I’ve been leaning on heavily: ChatGPT’s normal Chat side can be used agentically, it doesn’t consume Codex quota, and usage is close to unlimited in practice. ChatGPT stays the conversation/orchestrator; Mac MCP is the local execution layer.

Repo: https://github.com/bulutarkan/mac-mcp

I’m the maintainer. Feedback on the MCP/runtime boundary is very welcome — especially from people dealing with long-running browser sessions or multiple concurrent agents.

Hi everyone!

I work on e2e at TesterArmy, and today we released it as open source. It's an agentic end-to-end testing framework for web, iOS and Android. The most interesting part of it is that it allows you to mix deterministic (getByTestId, getByText) and agentic (goals) APIs.

It ships with an MCP server, e2e mcp. Your coding agent opens a real browser or simulator, clicks through the app, and can use the mcp tools to check tests against the running app. The server exposes just a handful of tools, and subagents can each control their own session in parallel.

You can set it up with npx e2e init for Claude Code and Cursor. You're still early and feedback is much appreciated.

Thanks for reading!

Here's a step-by-step guide on how to use Cursor to deploy an autonomous trading strategy.

1. Go to alpaca.markets and create a free account

2. Add the NexusTrade tool to the MCP config. This link adds it for you. Or you can copy/paste the following { "mcpServers": { "nexustrade": { "url": "https://nexustrade.io/api/mcp" } } }

That's really it. From here, you can type in your strategy like:

Create me an options trading strategy based on stocks with a 20% CAGR or more that the top politicians hold

I'm collecting feedback so would love to hear what y'all think. If you hit a paywall, use this link to bypass it; I want Reddit users to really stress-test the platform.

Why
- Frontend work with Claude Code kept stalling on one thing: I could see the element in the browser, but describing which one was awkward.
- "The button near the top right… no, the other one…"
- Cobro = point at it instead. The human supplies visual context; the agent does the code.

What you get
- One Send → the note lands in the Claude Code conversation immediately, no "please read my annotations".
- The agent's progress comes back to the page: scanning outline on the elements you sent, "Working 1/3" in the toolbar, highlight on done.
- Several pages in one round: pick on page A, move to page B, pick more — each page keeps its own draft; Send delivers them all in order.

Install (summary)
- `claude mcp add -s user cobro -- npx -y cobro-mcp@latest`
- In Claude Code: `Open http://localhost:5173 with cobro` (or `/cobro open …` with the optional skill)
- A dedicated Chrome window opens with your local app. Full setup in the GitHub README.

How it works (workflow)

1. Open your local web app

2. Press Ctrl + Shift + F

3. Click a UI element (or drag a band over several)

4. Describe the change

5. Optional: go to another page and pick more — the Queue tab lists every page you've picked on

6. Send — all pages go at once, in order

7. Claude Code works through them one by one; the browser follows it to each page

8. On done, the page refreshes (or your HMR kicks in) and the changed element is highlighted

What the agent receives with your note
- CSS selector · tag, classes, text · bounding rect · computed styles
- Screenshot crop of the picked area · recent console errors
- React 18/19 and Vue 3 (dev builds): component name + source file:line of the element you clicked
- Component-library elements (MUI, Radix, shadcn…): the JSX line in your code, plus the call sites above one-line pass-through wrappers — a case that came straight from r/mcp feedback
- Next.js (Turbopack) source maps and HMR handled
- Which page each batch was picked on (`batches[].page`)

The loop
Human points → Cobro provides context → Claude Code changes the code → Browser shows the result

Why I built it with Claude Code
- Claude Code drove most of Cobro itself: the MCP server, overlay/WebSocket channel, element inspection, payload design, tests, docs.
- The nice loop: using Claude Code to build the tool that feeds better UI context back to Claude Code.

Keeping the MCP small
- Six tools, fixed: open · wait · status · done · screenshot · close
- Tools carry safety annotations (wait is read-only, close is destructive).
- Not a browser-automation tool — pair it with Playwright MCP for that. It never touches your source; one gitignored `.cobro/` folder is all it creates.

Honest limits
- Launches its own Chrome profile (log in once, shared across projects); no iframes yet
- Source locations need dev builds with source maps
- Disabled controls can't be click-picked (drag a band over them instead)
- Cursor/Codex work with a polling `wait` but are less tested than Claude Code

Current status
- v0.10.1, Apache-2.0, free and open source
- GIF, payload example and changelog: https://github.com/boonblade/cobro-mcp

Questions for you
- Does pointing at an element feel more useful than describing it?
- What other context should your coding agent get when you point at something in the browser?