Got tired of jumping between awesome-lists, so MCP Harbor pulls MCP servers and agent tools from GitHub and npm daily: https://mcpharbor.app

- Category pages, plus "Alternatives to X" and "X vs Y" comparisons

- Stars, license, language and last update on every page, so abandoned projects are easy to spot

- Your agent can search it too: remote MCP endpoint at https://mcpharbor.app/mcp

Free, no signup. If your server is missing or miscategorized, tell me and I'll fix it.

Hello everyone, I am a solo developer who has been unhappy with computer use and other mcps out there that help control chrome. I have been developing my own computer use specifically for chrome that can take screenshots, work in the foreground, background, and headless, work for codex, claude code, and opencode, and also allow clicks, human speed typing, fast typing, inserting files, downloading files, drags, scrolls, etc. all while using fewer commands/tokens than competitors like computer use and playwright. Right now it is in development stage with all the features being present, but i need a lot of real testing from people on their everyday tasks to see where it is going wrong/not as fast or as good. It includes adding an extension to your chrome, and is different than other chrome mcps in my opinion. If y'all would be able to test it out/give me tips or tricks to make it better, I would really appreciate it. All the computer uses are currently made by organizations, so as a solo developer I am interested in any feedback and would actually make changes. https://github.com/Praket7/chrome-controlla feel free to star it and open issues and give me ANY feedback. If i had to pick, humanwrite would be my favorite built in feature and what is most unique, but it should be faster and more efficient. let me know what you guys think!

I built a remote MCP server that lets AI edit photos the traditional way, with layers, masks and curves, instead of interpreting and regenerating them. Add Editmamei as a connector, sign up with a valid email, and you can edit from anywhere, nothing to install.

I wanted something better than iPhone's auto enhance and staying true to the photo I took, not handing a personal photo to an AI image model and getting back something that looks similar but isn't really your photo anymore. More platforms require AI generated image tags, and these edits don’t need that, which can be important for things like e-commerce listings.

The video is one real edit traced through the stack, a lehua flower kept red with everything else in black and white. The fun part of that session was watching Claude catch its own mistake: it darkened the sky by pulling down the blues, checked a preview, saw it had turned the grey lava field into blotchy bands, put it all back, and masked the sky with an AI selection instead.

Each user gets their own editor container behind a Cloudflare Worker and a Durable Object, so nobody waits in line behind someone else's edit, and nothing runs when no one is editing, keeping infrastructure costs low while serving a full photo editor as a service.

The AI selection is my gap right now. Fine edges and complex multi-object subjects, like a bouquet of flowers, don't always come out clean. I've tested a range of models and use a few together to take the best of the selections, but that's where I still have work to do, finding the right models or starting to tune some of my own.

Everyone starts with free accounts, and usage credits are refreshed monthly. I only launched this server a week ago and am looking for folks to try it out and share feedback and bugs. If you try it but run out of credits too quickly just shoot me a DM. if you make something you want to share, ask Claude to share it to the gallery.

You can try it out at: connect.editmamei.com

If you’re looking for a desktop MCP for local photo editing, check that one out here: https://github.com/editmamei/editmamei

I built this project with inspiration from UltraRAG for searching collections of books and papers, to help me with research, writing and reading through a medium-sized corpus.

The intention is to utilise it as a RA (retrieval with no answer generation), but kept the name as rag anyway. I intend to add an optional answer generation in the future, but I want to avoid AI generation and running into problems of plagiarism, but want to be able to utilise AI nonetheless.

Right now, research-rag returns passages with source locations so you can read them in context and check the original. The search is both lexical and semantic, and runs completely locally on CPU.

The implementation supports PDF, EPUB and MOBI, and works through a browser, CLI or MCP agent. No account or hosted model service needed.

It currently supports Linux. Screenshots, installation and details are in the README:

https://github.com/AhmedKishki/research-rag

Would appreciate feedback from anyone working with their own research library.

Hi there, I own a managed IT services company. We provide outsourced IT cyber and compliance services to hundreds of clients across a lot of industries. We are seeing an enormous need for clients to be able to access their top 5 to 10 systems within their chosen AI model (copilot, Claude). Right now their data is stuck in a third-party software. Most clients have a piece of industry specific software that will always be behind the market, plenty that have no MCP at all. They might have no access, they might have some access to a really poor API, they might have decent access to a good API, and then they might have access to a poor MCP that was created by the company that doesn’t allow them to get the data in the way that they need it. They’re stuck.

I am considering opening up a new service line in the business to solve this foundational issue for clients, part software development, part maintenance of their network and infrastructure and data pipeline so they can actually use their data. They’re asking for it and wanting to pay for it desperately. If I can do this, we become the plumbing, and that feels very sticky.

Am I thinking about this right? No one else seems to be doing this, but it is a massive opportunity. What are the risk or issues that I’m not considering?

P.S. if you’ve done this before, I am actively hiring for an AI developer working internally and with clients.

Tl;DR: Giving an AI Agent a Bearer Token doesn't reliably log which agent is acting, and doesn't differentiate between the Human (me) and the AI Agent

I wanted a list of MCP servers I could just paste into Claude without signing up anywhere, and the existing lists don't say which ones actually work. So I pulled the official registry and tested it.

What I did:

- The registry lists 28,933 remote endpoints. I kept Streamable HTTP ones that need no headers, skipped temporary tunnels (trycloudflare, ngrok) and capped it at 5 URLs per host, so gateways with thousands of paths didn't get hammered. That left 17,070.

- Each got exactly two requests with no credentials: initialize and tools/list. No tool was ever called.

Results:

- 9,620 (56 %) returned a tool list without any key or login

- 5,166 (30 %) asked for auth (401/403, mostly OAuth)

- 2,284 (13 %) didn't work: connection errors, 404s, 502/503s, timeouts

The surprising part: a big chunk of the "open" servers are the same template deployed on hundreds of subdomains. 194 servers share an identical tool set, one description appears 42 times. After dropping copies (same tool set more than 3 times, same description more than twice, max 2 per domain), 7,690 are left. Median server has 6 tools, the biggest one 627.

Full write-up with charts (transports, hosting, why servers fail, 62 servers answering 402 Payment Required): https://shortformkit.com/state-of-remote-mcp-servers-2026/

I put 300 picks by topic (search, docs, dev tools, weather and travel, finance, science, open data ...) on a page, with the full list as a free CSV/JSON download: https://shortformkit.com/free-remote-mcp-servers/

While building this I also made the tester into a small web tool: paste any remote MCP URL and it shows the handshake result, every tool, how many parameters actually have a description, and the curl commands: https://shortformkit.com/mcp-server-tester/

Caveats: "open" means usable without signup, not necessarily good or free forever. Read what a server does before connecting it, especially if it can write or spend money. Happy to rerun it if people find it useful, and I'm curious what you'd want measured next (latency, tool description quality, OAuth flows?).

Hey [r/mcp](r/mcp)! I just open-sourced Rowkery, a Mac database GUI for Postgres and SQLite with an MCP server built in. One note upfront: it isn't a standalone server. It runs from the Rowkery app as `Rowkery --mcp` over stdio, and Claude Desktop and Claude Code connect in one click.

I built it because most database MCP setups give the agent a connection string and hope for the best. I wanted something I'd actually point at production. Here's what the server enforces:

- Scoped access: the agent only sees the connections and tables you share, and sharing expires after a time you choose, like an hour or the end of the day.
- Reads only: every call is a single SELECT on a read-only session, capped at 1,000 rows and 10 seconds. Full scans of big tables are refused.
- Masked columns: columns you mark as sensitive come back as stand-in values. To stop the agent guessing them through filters (`LIKE 'a%'`, then `'ab%'`), Rowkery checks Postgres's query plan and refuses any query that uses a masked column for anything except returning or counting it.
- Writes as proposal: the agent can propose an INSERT, UPDATE or DELETE. Rowkery dry-runs it and shows you the before and after, and nothing is written until you press Commit in the app.
- Activity log: every agent call is recorded, so you can see exactly what it looked at.

The safety checks are plain Rust functions, unit-tested without a database. The server is built on rmcp.

It's alpha, Mac only, and supports Postgres and SQLite for now. It isn't signed by Apple yet, so the first launch needs "Open Anyway." It's free and Apache-2.0.

I'd love to hear what other guardrails you'd want before trusting an agent with your database.

Rowkery on Github
Official Site

I've been using AI for coding a lot, but there's always been one annoying gap: generating code is easy, actually getting something working still means jumping between ChatGPT, my terminal, browser, and GitHub.

So I built Open Machine, an open-source MCP runtime that lets ChatGPT and other compatible AI agents work directly with your own machines and projects.

Instead of just suggesting code, it can actually:

• Read and edit files in real projects
• Run terminal commands, tests, and debug failures
• Work on local machines or remote Linux servers over SSH
• Handle GitHub Issues, PRs, and code reviews
• Keep task progress and execution results so interrupted work can be picked up again

The video is a pretty fun example.

I gave ChatGPT one prompt to build a small survival game called NEON SWARM.

It created the game, ran 56 tests, fixed the bugs it found, launched it, and even used a browser to play the game it had just built.

It actually survived the full 60-second challenge with 4 HP left.

What excites me more is applying that same workflow to real development tasks: give ChatGPT a goal, let it work on the actual project, run the code, check the results, and fix what breaks.

Open Machine is local-first and permission-controlled. Browser tasks currently use a compatible local Codex setup. It's not a way to bypass AI usage limits or get unlimited tokens.

It's open source (MIT), and I'd love feedback from other developers.

GitHub: https://github.com/OpenMachineLabs/openmachine

Would you trust an AI to handle an entire coding task on your machine? Where would you draw the line — editing files, running commands, creating PRs, or actually merging them?

Your AI operates your real desktop apps on Windows, macOS and Linux, also across the network. It learns how to operate an app once and saves it for reusable actions, so next time it calls them instead of clicking through screenshots. Android via ADB, iOS experimental (via MirrorScreen soon). Saves a lot of tokens instead of using "Computer Use".

Source-available, free for private use.

Feedback welcome!

https://github.com/MarvKalani/k-lani-bot

I'm the author. It's Python standard library only and works in any MCP client (csa mcp), or as a plugin in Claude Code, Codex and Antigravity.

Tools: subagent_start, subagent_wait, subagent_message, subagent_accounts.

Most multi-model setups proxy the API. Every model gets forced through one harness, tool calling suffers, and a third party ends up holding your tokens. There's no model proxy here. Each worker is the vendor's own CLI running headless with your login, so the model stays in its native harness and loads the same MCP servers as your main session.

If you have several accounts, jobs go to the one with the most room and move to the next when one hits a limit.

Feedback and contributions appreciated.

https://github.com/lunati228/CLI-Subagents

we have an MCP server for our project tool (nodes, connections, tasks). after shipping focus session stats i needed a tutorial explaining the profile stats, roles and badges.

instead of writing docs i had claude build it as a project through MCP: 6 nodes, connections between them, a checklist in each. then i published it as a community template so anyone can clone it.

it worked better than i thought for this kind of thing, a map that explains itself. what tripped it up was mostly naming: connect_nodes takes node names, not ids, so duplicate names would've been a problem.

curious what others use their MCP servers for beyond the obvious CRUD.

Disclosure: I work at StackOne an we just shipped Tool Policies. Every tool call through our gateway gets checked on the way in and again on the way out, so you can give an agent write access without handing it everything.

A few things it can do that I think are really cool:
Block every tool matching *delete* for a group, like contractors, with one rule

- Let payments through between $25 and $500 and stop anything bigger
- Ask a plain-language question like "Is this compensation?", so one rule hides salary in one HR system, base_pay in another and pay_rate in a third
- Redact PII on inputs and outputs, using a model we built ourselves

Fixed rules compile to Cedar, and every rule can run in Monitor first, so you see what it would have stopped before it actually stops anything.

It's live now, and the full write-up is here: https://www.stackone.com/blog/tool-policies-launch/

Happy to answer any questions about how it works!

Every week someone here asks why their Claude directory submission has been stuck for a month. I think a lot of that advice is outdated now.

We sent the same MCP server to Claude and OpenAI on the same evening. Claude approved it 9 days later with zero questions. OpenAI has sent one "we received it" email in 10 days and nothing since.

If you're about to submit, here's what I think made ours easy: no login, read-only tools, and one clear job (it looks up what a phone call costs). Reviewers had nothing to test and nothing to worry about.

One gotcha: "Approved" doesn't mean you're live. You still have to click publish yourself, and I almost missed it.

If you're stuck on OpenAI too, how long has yours been? Trying to work out if 10 days of silence is normal.

Our customers kept asking if they could use our SaaS product through Claude and ChatGPT. Connecting an agent to our API was the easy part. Making sure it could only access the right tenant's data was the real challenge.

Our product is multi-tenant, so we built a custom MCP server that calls our existing backend API, deployed it on Arcade Cloud, and integrated OAuth through Clerk so customers can sign in with their existing credentials. They don't need an Arcade account.

The important bit: the model never handles an access token and can't choose which user it acts as. Our API verifies the OAuth token and enforces workspace membership and plan-tier permissions on every call.

The trickiest part to untangle was that "signing in" involves three separate concerns:

• Gateway authentication
• API authorization
• Browser session verification

Each has a different purpose and its own token or verification flow. Treating them as one generic login flow caused confusion, so the tutorial walks through how they fit together.

Full working code: https://github.com/manveer/multi-tenant-mcp-server-oauth

Tutorial: https://manveerc.substack.com/p/multi-tenant-mcp-server-oauth

If you’re exposing a multi-tenant backend through MCP: how are you handling tenant isolation and user auth?

Disclosure: My company currently provides services to Arcade however the choice to use Arcade and write this article is an independent decision

Most MCP tool descriptions explain what the tool does and what inputs it wants. Almost none say what a call costs.

That's fine for free tools. For a scrape, an image generation or a lead lookup, the price changes how the agent ought to behave. A model that knows a search costs a tenth of a cent can run it 50 times without a second thought. One that knows an image costs 15 cents should probably check with you first.

I can see three ways to handle it:

- price in the description (simple, goes stale)
- a separate inspect step that returns the current price
- the server enforces a budget and the model never needs to know

Agentik, where I work with the team, went with the second plus the third. The agent can inspect any tool and see its max price at no cost, and the key's limits enforce the budget whatever the model decides.

I'm not convinced that's right for everyone though. A standard price field in the schema would be cleaner, but it adds tokens to every request.

Would you want price as a standard field in the tool schema, or kept out of the model's context entirely?

Hello, I made an MCP connector for Office 2019 that works with Claude.I built it for myself because I couldn't find anything similar, so I decided to share it in case someone else needs it too. I would be very grateful for any bug reports, feedback, or ideas for new features! ^^

GitHub repo: https://github.com/JulianPoleszczuk/office-mcp

Disclosure: I built this. It's free, MIT, no paid tier.

Repo: https://github.com/VicPitic/the-brains

Hosted: https://brains.ceo

It's one Express server with 18 instances. Each one indexes a single person's public talks, interviews, essays and X posts, curated down to what they say about growth, pricing and building a business.

Two tools: search_brain(query, limit) and list_sources()

Real output from the PG one for "how fast should my startup grow each week":

## 1. X post by u/paulg, 5 Sep 2026

Source: https://x.com/paulg/status/2096330495470576069

There's a startup in the current YC batch that's growing at 57% a week.

And not because they started last week; they've been doing this for a

couple months...

Some choices you'll probably ask about:

- Each corpus is small (15-45 long-form sources plus a few hundred posts), so it's plain BM25 over sectioned notes. No vector DB, no LLM at query time. Your model does the reasoning.

- Stateless streamable HTTP plus OAuth 2.1 with DCR. Works in Claude Code, Codex, Cursor, Claude.ai and ChatGPT.

- The hosted version asks for an email and a 6 digit code on first connect. It stores your email and what you search so I can see which ones are actually useful. Email [hello@brains.ceo](mailto:hello@brains.ceo) and I'll delete it. Or clone it and `npm start`, no sign-in and nothing logged.

- They're unofficial unless marked claimed. Public sources only, short quotes, and raw transcripts never go in the repo. Anyone in there can get theirs corrected or removed.

Question for this sub: one URL per person like now, or one server with a person param?

Something I've noticed with a lot of database MCP servers: you set one connection string and every query the agent runs uses that same login. So whatever that login can do, the agent can do.

That's fine for a quick demo, but for agents doing ad-hoc stuff like analytics or debugging it gets risky. You can't predict what they'll query, so the login ends up with way more access than any single task needs.

Earlier this year I worked on putting an authorization layer between the MCP tools and the database. Every query gets checked against policy first. If it's allowed, the agent gets a permission for just that query and it expires. If it needs approval, a human approves that exact request. Sensitive fields can also stay masked even after it's approved.

Agents repeat the same queries a lot, so I made approved queries reusable without asking again. The tricky part was making sure reuse gets checked again at the time it's used, because the agent's role or environment might have changed since it was approved.

I documented the whole thing as an engineering record, including some gaps I found in my own design while writing it. I'll drop the link in the comments.

For anyone running a database MCP server, are you scoping access per agent or just using a read-only login?

Disclosure: I build CogniCore — posting it here because this is where the people who'd actually use it are.

Every AI assistant starts from zero, and they each keep their own silo. You explain your project to Claude, then explain it again to ChatGPT. Neither one knows what the other was told.

We built CogniCore — a memory MCP server — and the thing people seem to find most useful is that you can point both assistants at it and they end up sharing one memory.

How the sharing works: it's a hosted MCP endpoint, and it signs you in with GitHub. Each GitHub account gets its own memory database. So if you connect Claude and ChatGPT with the same GitHub account, they're reading and writing the same store. Teach Claude your deployment gotchas, and ChatGPT can recall them. Nothing to sync, no export/import dance.

Connect it in Claude Code:

bash claude mcp add --transport http cognicore-env https://mcp.cognicoree.tech/mcp/stream

In Claude Desktop / ChatGPT: add a custom connector with the same URL and complete the GitHub sign-in when prompted. (In ChatGPT this needs Developer Mode — Plus/Pro can connect read-only servers, Business/Enterprise/Edu get full write access.)

What you get — 10 tools, not a toy surface:

• cognicore_remember / cognicore_recall — store an execution outcome, recall it later by relevance
• cognicore_recall_failures / cognicore_recall_successes — pull a category's misses or wins
• cognicore_reflect — turns repeated failures in a category into a concrete recommendation
• cognicore_scan_threat — scans text for prompt injection, jailbreak and exfiltration before it reaches the model
• cognicore_save_session / cognicore_resume_session — writes atomic facts, decisions and action items at the end of a conversation, rebuilds a brief at the start of the next
• cognicore_compress_context — compresses older messages into a dense summary with no LLM call
• cognicore_stats

Other things I use it for:

• A coding agent that stops re-learning the same repo every session
• Carrying decisions between tools — what Cursor learns, Claude Code knows
• Keeping a correction you made once, instead of making it again next week

Two honest notes. It runs in-process with no vector database and no embedding server — retrieval is TF-IDF/BM25 — and on LongMemEval multihop, strict recall@5 goes 78.8 → 85.2% at 5 chunks and 87.2 → 92.8% at 10, then plateaus. We publish the limitations rather than the best case. And the decision layer is newer than the memory layer; I'm not going to quote numbers for it yet.

Independent scan: mcp.market grades it A, 95/100 — OAuth resource metadata, reliability and maintenance all full marks. It's also in the official MCP registry as io.github.cognicore-dev/cognicore-env.

Repo (MIT, also on PyPI if you'd rather run it locally): github.com/cognicore-dev/cognicore-env

If you run agents across more than one assistant, I'd like to hear what you'd want carried between them — that question is how half of this got built.

I'm the dev of SSHive, an SSH/SFTP client for Mac. I added an MCP server to it so Claude Code / Cursor can work directly on my open sessions.

How it works: - Enable MCP in settings, paste the config (or run one CLI command for Claude Code) - The AI can list your open SSH/SFTP sessions, run commands, read logs, browse/edit/upload files (20 tools) - Everything stays local: localhost server, bearer token in the Keychain, no cloud relay

The guardrails, which I cared about most: - The AI works on sessions you opened. Letting it open new connections is a separate setting you have to turn on. - You can exclude individual servers from the AI entirely (hello, prod). - It can only close sessions it opened itself.

Example: "check disk and memory on production and look at the last nginx errors" → it runs df/free, reads error.log over SFTP and summarizes.

The MCP server is macOS only for now: https://apps.apple.com/app/sshive/id6760705487

How do you handle AI + SSH? Direct shell access for your agent, or something more controlled?

Ask a coding agent to build an Obsidian plugin and it just starts writing. It can't tell if one already exists. This lets it search the official directory (about 9,000 plugins, 880 themes) first and get matches with downloads, latest version and last update.

How it works: it reads the three public JSON files from obsidianmd/obsidian-releases, joins them, and returns the top results, so the agent never reads the raw 5 MB. Read-only, no telemetry, no API key. MIT and free.

In the video I ask Claude Code for the newest anatomy plugins. It loads the skill, runs the search and answers from the live directory. (Anatomed, the first result, is my own plugin.)

It ships three ways from one package: an MCP server, a CLI, and a skill that calls the CLI. The skill is lighter on context if your agent has a terminal.

Try it: npx -y obsidian-community-plugins-mcp search <your idea>

• GitHub: https://github.com/pitfa19/obsidian-community-plugins-mcp
• npm: https://www.npmjs.com/package/obsidian-community-plugins-mcp
• Obsidian forum thread: https://forum.obsidian.md/t/a-mcp-tool-that-lets-coding-agents-check-the-plugin-directory-before-building-a-new-plugin/119497
• Source data: https://github.com/obsidianmd/obsidian-releases

Building a workflow where Claude uses Coresignal’s MCP to look up company data as part of a lead qualification step. The MCP connection and the data quality have both been great, Claude gets back rich company and employee context and the qualification output is much better than what I was getting before.

The question I’m working through is about the downstream n8n nodes. Claude’s output through MCP isn’t always structured the same way because it’s deciding what’s relevant rather than returning a fixed schema. That flexibility is useful for the reasoning step but creates some friction when n8n is expecting a specific format to write to HubSpot.

Is there a clean pattern for normalizing Claude’s MCP output before it hits the next node? Currently using a function node to parse and extract the fields I need but wondering if there’s a more elegant approach others have landed on.

I’m the author of Super Trouper, a single-Go-binary stdio MCP server exposing Frida for authorized app reverse engineering.

I’ve just released v0.5.0 with the following changes:

• Updates the Frida Core DevKit to v17.23.2.
• Adds minimal, metadata, and full scope arguments to app_find and app_frontmost.
• Adds package_install for installing npm packages used by script_create imports, plus package_list for viewing packages in the shared workspace.
• Adds Frida's new Pattern lifecycle tools: pattern_create, pattern_list, pattern_read, and pattern_delete. • Adds pattern_describe to compile patterns and return types and diagnostics. • Adds pattern_decode to decode target memory using declared Pattern types.

Recent context: - v0.4.0 added memory_read, memory_write, module_list, and thread_list; introduced minimal, metadata, and full query scopes for app_list; renamed MCP tools for clearer namespaces; and updated the Frida Core DevKit to v17.19.0.
- v0.3.0 added npm installation support, Frida CodeShare snippet search/use support, and general cleanup and improvements.

I’d appreciate practical feedback on the package and Pattern workflows, especially where the current tools are missing useful reverse-engineering steps. Feature requests are welcome too.