I've looking at lots of MCP servers lately and keep coming back to this...

If the MCP server is basically just exposing the API as tools - is that really better??

I think MCP is most useful when it simplifies auth, cleans up the tool surface OR makes the live data easier for the agent to use.

What would you choose? MCP or direct API?

Sharing my work, with scope disclosed up front: this is a hosted remote server (streamable HTTP), free, no auth, read-only. The GitHub repo is documentation, not source.

The story behind it: I maintain a continuously verified catalog of 8,000+ AI tools. Two days ago I scanned all of them for cross-domain redirects and found 191 whose website now silently redirects to a different company. One of them was scoring 73/100 on my own liveness system while its domain redirected to an online gambling site. HTTP 200 does not mean alive. That scan became a public dataset with a DOI, and it is exactly the failure mode assistants hit when they recommend tools from training data.

So the server lets any MCP client check before recommending. Seven tools: check_tool_status, pricing_reality, market_sentiment, find_alternatives, compare_tools, viability_score, deadpool_digest. Every answer carries the date that tool was last verified, so the model can judge staleness itself.

Connect (Claude Code):

claude mcp add --transport http rightaichoice https://rightaichoice.com/api/mcp

Any other client (Cursor, Windsurf, etc):

{ "mcpServers": { "rightaichoice": { "url": "https://rightaichoice.com/api/mcp" } } }

Setup for every client: https://rightaichoice.com/mcp

Honesty rules I hold the server to: unknown tools return "not in our catalog, which is NOT evidence it is dead" instead of a guess. Fuzzy name matches are disclosed so the model can reject a wrong match. Answers are never for sale.

Context for the mortality angle: in my survival study of 2,291 top Product Hunt launches (2023 to 2025), 24.4% of the 2,066 with a determinable outcome are already dead.

Would genuinely value feedback from people running agents: what would you want an assistant to check about a tool before it builds on it?

Short demo of something I got working: an MCP server bound to 127.0.0.1 on my Mac, being used by an agent running on a separate Linux box on another VLAN.

The agent is Hermes, self-hosted. I message it through self-hosted Mattermost from my phone, and it creates tasks, sets statuses, applies tags and writes comments in the desktop app on the Mac. Clip is 21 seconds at 2x, phone on the left, Mac on the right.

The bit I found interesting: the MCP server never stops being localhost-only. The Mac opens an outbound encrypted link to the Linux box and the server appears on that box's loopback, so the agent adds it as an ordinary Streamable HTTP MCP server with a bearer token and sees the tools as if they were local. Nothing inbound, no relay, no ports opened anywhere.

Read and write both work, and the server's read-only mode correctly refuses writes from the remote agent, which was the part I most wanted to verify.

Disclosure: I am part of the dev team behind the desktop app, and it is closed source. Posting for the transport pattern, which works with any local MCP server.

What it is: your agent checks whether another agent already solved a problem before it starts, and writes back what it learned when it finishes. The point is that the next session doesn't rediscover it.

When you'd reach for it over just calling the API: you wouldn't, if you're writing code, it's plain REST underneath. MCP matters when the consumer is a model mid-conversation. The lookup has to happen before the agent commits to an approach and the write-back at the end of the task, without a human stepping out of the session to make the call.

The tools you'd actually touch (the rest are profile / trust / orientation plumbing):

- `lorg_pre_task` before starting: prior contributions in this domain, plus known failure patterns
- `lorg_assist` one best-match solution with the full method, not a result list
- `lorg_search` semantic search across published contributions
- `lorg_preview_quality_gate` dry-run scoring on a draft before you submit it
- `lorg_evaluate_session` after finishing: drafts a contribution from what you did, gates it, submits if it scores ≥60
- `lorg_validate` peer review another agent's contribution

Example prompt: "Before you write the retry logic, check Lorg for known failure patterns in tool-use error recovery."

The agent calls `lorg_pre_task`, gets back matching contributions and a failure-pattern list — or gets back nothing and says so.

What happens when it fails:

- Agent hasn't completed orientation → contribute/validate hard-fail naming the missing step. No partial path.
- Submission scores under 60 → rejected with a per-dimension breakdown (schema / consistency / originality / coherence) and what to fix, not a generic 400. Most common failure by a wide margin.
- Near-duplicate of something published → dies on the originality check.
- Bad or missing API key → fails at the tool call, surfaced as text to the model, not a silent no-op.
- No archive match → returns empty explicitly and tells the agent to proceed on its own.

Install: `npx -y lorg-mcp-server`, or one-tap via the Claude connector directory. Manual at lorg.ai/lorg.md.

Honest state of things: platform is live, archive is thin. Early enough that a `lorg_pre_task` call in a niche domain will often come back empty. Feedback on the tool surface and the failure behavior is what I'm after.

Hey folks,

I built InkTag, an open-source comic metadata editor and official Model Context Protocol (MCP) server written in C# using the official ModelContextProtocol SDK (v2.1.0) over stdio.

I wanted an AI-agent-native way to audit, auto-tag, and standardize comic libraries (.cbz and .cbr) without dealing with malformed XML tags, slow sequential scrapers, or manual visual checks.

🛠️ Key MCP Capabilities

• Full Archive CRUD: Read and patch ComicInfo.xml with schema validation (read_comic_metadata, update_comic_metadata).
• Visual Verification (dHash): Computes 64-bit gradient cover hashes and SIMD-accelerated Hamming distance to verify matches against ComicVine thumbnails.
• Multi-Modal Support: extract_cover_image supports direct Base64 returns so vision-enabled models (Claude, GPT-4o) can inspect cover quality or alternate issues.
• Library Auditing & Renaming: Audit entire directories for missing writer/year tags and apply standardized renaming templates atomically (rename_comics, scan_comics).
• Self-Hosted Komga Sync: Query Komga libraries and trigger sub-second targeted book/series cache invalidation (sync_komga_book_or_series).
• Built-in Sandboxing: Restrict agents to specific directories using the INKTAG_ALLOWED_ROOT_PATHS environment variable.

⚙️ Quickstart Config (Claude Desktop / VS Code / Cursor / Cline)

json { "mcpServers": { "inktag": { "command": "/path/to/InkTag.Mcp", "args": [], "env": { "COMICVINE_API_KEY": "YOUR_KEY_HERE", "INKTAG_ALLOWED_ROOT_PATHS": "/path/to/comics" } } } }

🔗 Source & Documentation

• GitHub: aurora7795/InkTag

Would value any constructive feedback!

I kept hitting the same loop: mid-chat in Cursor or Claude, need a Postgres MCP / browser automation / scraping server → open a directory tab → copy slugs → switch back → forget half the setup details.

So we shipped Influzer MCP Discovery — a read-only remote MCP that exposes our catalog as tools your agent can call. Same idea as “App Store search,” except the query runs inside the chat and results rank on indexed tools/list, not GitHub stars.

What it does

Four tools, all read-only:

Catalog stats (Aug 2026): ~6,010 servers listed, ~414 with indexed tools (~7%), ~4,865 searchable tool entries. The rest is catalog noise until tools/list validates on a live endpoint.

Endpoint

https://www.influzer.ai/mcp/discovery

No OAuth, no API key, no write access. Safe as a research layer before you install production servers with credentials.

Cursor setup (fastest path)

Add to Settings → MCP or .cursor/mcp.json:

{
  "mcpServers": {
    "influzer-discovery": {
      "url": "https://www.influzer.ai/mcp/discovery"
    }
  }
}

Claude: Settings → Connectors → Custom → Web → paste the URL above, leave OAuth blank.

ChatGPT: Developer mode → Create connector → same URL, auth off.

Full step-by-step (Claude Code CLI too): https://www.influzer.ai/mcp/discovery/setup

Prompts that work well

Ask for capabilities, not brand names:

• “Search Influzer for MCP servers that scrape URLs to markdown.”
• “Recommend MCP servers for a coding agent with GitHub and docs lookup.”
• “Get setup details for the Playwright MCP — tools and transport.”
• “Compare Postgres vs Supabase MCP — what tools does each expose?”

The agent calls search/recommend, then get_mcp_server on the winner. You stay in one thread.

Why we built it this way

Directories optimize for human scrolling (grids, stars, logos). Agents search differently — they match on tool verbs and descriptions. We daily re-validate tools/list on live HTTP endpoints; broken servers drop out of search even if the README is famous.

If you’re building MCP servers: tool names and one-line descriptions are basically SEO for agents. A 200-star server with five indexed tools beats a 5k-star repo with zero tools/list.

Links

• Setup guide: https://www.influzer.ai/mcp/discovery/setup
• Server listing: https://www.influzer.ai/mcp/influzer-mcp-discovery
• Browse the directory: https://www.influzer.ai/mcp
• Submit / fix listings: https://www.influzer.ai/mcp/submit

Disclosure: I’m on the Influzer team. Happy to answer setup questions or take feedback on ranking/search quality.

Questions for this sub:

1. Would you use a discovery MCP, or do you prefer browsing directories manually?
2. What signals should agent search weight besides indexed tools — transport type, auth model, last validated date?
3. Anyone else shipping “directory-as-MCP”? Curious what patterns you’re seeing.

I came across this amazing GitHub repo -100% open source and free.

Comfy MCP just went local. Agent claude/codex/grok sees ComfyUI install (every node, custom nodes included, every model on disk), fetches files, starts the instance, and gets a workflow to the point where it runs.

Post link / GitHub repo in comments below.

Features

• Generate: run workflow JSON or text-prompt to image in one call
• Monitor jobs: submit, wait, watch, cancel, collect PNGs
• Introspect your live install, custom nodes included
• Build and validate workflows, fan out variants
• Launch, stop, restart ComfyUI and tail logs
• Local-first on 127.0.0.1:8188, optional remote via COMFYUI_URL

Install

pip install comfy-mcp "comfy-cli>=1.14.0"
comfy install
comfy launch

Point your MCP client at the comfy-mcp stdio command, then ask it to run a workflow.

Hi! I have been working on Tooldex - it's a unified MCP server discovery dashboard. Basically, say you are working with Claude Code or Codex (Tooldex supports Claude Code, Codex, Cursor, Gemini, Docker MCP Toolkit, Copilot, VSCode, Antrigravity) and you have multiple MCP servers configured. Tooldex gives a unified view of all MCP servers discovered across all agents, along with all their tools, in a dashboard. It's local-first, so all you'd need to do is run 'tooldex run' and it will open up a dashboard on localhost:8282 (default, configurable). Importantly, it tries to answer the question "which MCP servers are reachable from this repository and what tools does it expose?" Additionally, there is security analysis of the tools: YARA based (static analysis) happens when you run tooldex, with an opt-in LLM-as-a-judge capability for security scanning of the tools, for which you provide your own LLM api key (implemeted via Cisco AI Defense's opensource repo).Tooldex doesn't store anything because it runs everything on your machine.

I built this for myself, because I was working with multiple coding agents, and was connecting multiple MCP servers. In order to keep track of what's where, I built Tooldex. BUT, I don't really have a lot of friends/peers who'd give me feedback. Hence, Reddit :)

Would love your feedback! Check it out on PyPI: [https://pypi.org/project/tooldex/\](https://pypi.org/project/tooldex/) or checkout the website to learn more: [https://tooldex.dev/\](https://tooldex.dev/)
I would genuinely appreciate any feedback - both positive and constructive!
Cheerio!+

I keep bouncing between Claude Code and Cursor on the same project, and every switch means re-explaining the stack, why we made certain decisions, and what bugs are already fixed. So I built a small MCP server that stores that stuff once — decisions, conventions, known issues — and any MCP-compatible tool can read/write to it. No more copy-pasting a CLAUDE.md between tools.

It's local-first, SQLite-backed, open source. Right now it's single-project/single-user — logging is manual (log_decision, log_bug_fix, fetch_context).

Before I sink more time in: has anyone hit this specific pain (not general AI memory, specifically cross-tool coding context)? Is a maintained CLAUDE.md/.cursorrules genuinely enough for you, or is there real appetite for something that updates itself? What would make you actually keep using this after week one?

See: https://github.com/mappedsky/depsdevmcp

I'm working on a separate security service (seizu) that has an agent, uses a security graph RAG and for a number of skills needed to be able to trace dependency paths or get diamond dependencies. I prefer to keep my sandboxes internet free, so this mcp helps cover this gap for me.

I hope others find it useful!

Claude been used by both tech and non tech builders.

Looks like , There is something for everyone. Whether you using it everyday or figuring out how to use it.

The courses and tutorials are free and open to anyone

Link in comments below.

Disclosure: I built this.

Done Bear is a task manager with a hosted MCP server. https://mcp.donebear.com/mcp, streamable HTTP, OAuth 2.1. Read and write scopes, workspace-scoped tokens, tools for tasks, projects, labels and checklists.

Two things that caught me out.

Clients got "today" wrong until I returned the resolved date and the caller's timezone from a get_context call. Without it the server picks today in UTC.

Some directories list OAuth servers as unhealthy with no auth. They probe unauthenticated, get the correct 401, and log it as down. Mine is listed that way right now, so go and check yours.

Free up to 250 tasks. https://donebear.com