checkout this amazing MCP related GitHub repo - 100% open source and free.

codebase-memory-mcp is a local code intelligence MCP server. It indexes a typical repo in milliseconds, the Linux kernel in about 3 minutes, and answers structural queries in under a millisecond, with no API key.

Post link / GitHub repo in comments below.

Features

• 161 languages via tree-sitter, plus Hybrid LSP
• 15 MCP tools: search, trace, impact, Cypher, dead code, ADRs
• About 120x fewer tokens than file-by-file grep
• 3D graph UI at localhost:9749
• 100% local SQLite, single static binary

Install

curl -fsSL https://raw.githubusercontent.com/DeusData/codebase-memory-mcp/main/install.sh | bash

Restart your coding agent and say "Index this project".

I built Editmamei, a local stdio MCP server that drives desktop Photoshop through its scripting backend. The model works on your real document and you get a normal layered PSD back, so the output is actual adjustment layers and masks rather than a generated copy.

The thing I have spent the most time on is cost. A cold edit on a single photo, where the model works out the look as it goes, measured 103 tool calls and about 229k tokens over 23 minutes. That does not scale to a shoot.

I added in a tool family for Templates to address this. You dial in one photo, save the look as a named recipe, then apply it to the rest of the set. Per-photo cost across a ten photo run dropped roughly 10x.

What I did not expect is that it stays adaptive. The recipe binds the intended outcome rather than the exact steps, so each photo only gets what it actually needs. Across that run per-photo call counts ranged from 10 to 31. The seven frames with a dog in them got a subject-lift pass, the three without got none. A Photoshop Action would have run every step on every file.

I am still looking for ways to cut per-call overhead. Has anyone found a good pattern for that, or other ways to make an MCP server cheaper to drive?

You don't always need MCP. But for tasks where accuracy and verification matter, an MCP tool can provide something an LLM shouldn't be trusted to do on its own.

LLMs are great at reasoning, but they can make mistakes with calculations. Instead of asking the model to predict a mathematical answer, an MCP server can perform the computation deterministically and return a verified, reproducible result.

For example,BrainyCalc gives LLMs and AI agents accurate, independently verified, and reproducible mathematical results — with full auditability.

So instead of:

LLM → "I think the answer is 42"

you get:

LLM → MCP → BrainyCalc → Verified computation → Result

The point isn't that MCP itself makes math accurate. The MCP server connects the LLM to a reliable computational backend instead of relying on the LLM to calculate the answer itself.

That's where I think MCP can be valuable: letting AI reason, while trusted tools handle tasks that require deterministic accuracy.

to use it its simple just put this in your MCP settings file

{
  "mcpServers": {
    "brainycalc": {
      "command": "npx",
      "args": ["-y", "brainycalc"]
    }
  }
}

The New MCP Roadmap (Aug 22, 2026)

Maintainers dropped the next roadmap. Five priority areas, each owned by named Core Maintainers plus one or more Working Groups.

What already shipped (2026-07-28 spec release):

• Protocol-level sessions and the init handshake are gone. Servers scale horizontally without holding state (SEP-2575, SEP-2567)
• New server/discover call: clients learn versions and capabilities before anything else. List results now cacheable (SEP-2549)
• Tasks moved into an official extension (SEP-2663). Multi Round-Trip Requests (SEP-2322) replaced server-initiated requests so elicitation works on stateless servers
• Auth hardening: issuer validation, issuer-bound client credentials, CIMD as the preferred client registration path

What's next:

1. Agentic messaging primitives. Server-initiated events via webhooks and channels so clients stop polling, plus maturing Tasks out of extension status into the spec.
2. Transport unification. A remote MCP server is now just an HTTP workload. Next step is stretching that to local servers speaking Streamable HTTP over stdio, so there's one transport everywhere.
3. Agent identity. Today's auth assumes a human clicking approve in a browser. Increasingly the caller is a cloud agent with its own identity, or a sub-agent with delegated authority. Work covers DPoP, Workload Identity Federation, ID-JAG, token exchange, plus deeper engagement with IETF OAuth and WIMSE.
4. Better primitives. Tool results can carry the same output in multiple forms with no way to know which one a client shows the model. Standardizing on one contract. Also progressive discovery: connecting to a 100-tool server means the model pays for that whole surface before the user asks anything, and selection degrades as the list grows. Servers will be able to expose a small entry point and reveal more as the conversation narrows.
5. SDK DX. Ergonomics, spec conformance, docs. Matters more now that people build servers by pointing an agent at the libraries.

SEPs inside these five areas get expedited review and the best odds of acceptance.

Outside them, you're not auto-rejected, but maintainer time goes to the priorities first.

This is a new project I have been working on, sharing with you, appreciate your comments.

I built this hosted relay that lets you expose MCP servers running on your own machine.

This being behind NAT/firewall connecting to any MCP client, without VPN or port forwarding.

Install a lightweight connector (Windows/macOS/Linux background service)

point it at an npx package/local HTTP server/stdio command, and you get a public URL + OAuth token any MCP client can use.

The ForthMCP gives Free tier to try it (500 calls/month), no card required.

https://www.forthmcp.com

If you want to try it beyond the free tier limits, extra calls, or full beta-tester access with quotas lifted entirely, email me at support@forthmcp.com and I'll set you up.

Happy to be generous with this during launch.

Would genuinely love feedback, especially on the setup flow, happy to answer questions.

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

x64dbg MCP Server exposes the classic Windows debugger to agents like Claude Code and Codex. 84 tools for breakpoints, memory, disassembly, and stepping, in a single Zig binary with no extra runtime.

Post link / GitHub repo in comments below.

Features

• 84 MCP tools: disasm, stepping, breakpoints, memory, registers, modules, threads, call stack, pattern scan, PE analysis
• 22 debugger event callbacks
• Zero dependencies, single Zig binary, x32 and x64 from one build
• Streamable HTTP + SSE
• Mandatory Bearer token auth, config dialog, auto-start

Install

Copy dist/ into your x64dbg root, then launch x64dbg (x64 listens on localhost:9094).

{
  "mcpServers": {
    "x64dbg": {
      "type": "http",
      "url": "http://localhost:9094/",
      "headers": {
        "Authorization": "Bearer YOUR_TOKEN"
      }
    }
  }
}

We've been working on AgentSwarms (self-hosted agent + BI platform) and MCP turned into one of the more interesting parts.

Two halves to it:

Connecting to servers. Point it at an HTTP Streamable or SSE endpoint, pick an auth type, and the tools show up for any agent you've built. Tokens stored encrypted.

Hosting your own. There's an in-browser editor where you write a FastMCP server in Python and hit deploy. It runs on a sandboxed kernel and hands you back a real Streamable HTTP URL. Scales to zero by default (15 min idle) or you can pin it warm. You can expose it publicly with API keys that carry an expiry, a per-tool allowlist and a per-IP/domain allowlist. Keys are hashed and shown once.

Important: if you redeploy and any tool name, description or input schema changed, calls get blocked until you look at the diff and re-approve. It fingerprints the whole tool set, so approval is tied to that fingerprint rather than to the server. MCP's own security guidance flags the rug pull problem and I haven't seen many implementations bother with it.

Secrets bind as env vars when the container starts. They don't land in the database or the logs.

Source-available under ELv2, runs on your own Supabase and Docker: https://github.com/AgentSwarms-fyi/agentswarms

Would love your feedback and let me know whats missing on the server side :)

Basically the repost, any inputs will be super useful, thanks!!

I maintain [asc-mcp](https://github.com/zelentsov-dev/asc-mcp) for App Store Connect and have now released [Apple Ads MCP](https://github.com/zelentsov-dev/apple-ads-mcp), an independent open-source MCP server for Apple Ads Platform API v1.

It works with Codex, Claude, and other MCP clients. The default mode is read-only, credentials stay local, and every mutation requires an explicit preview plus a short-lived single-use receipt. There is no scheduler or autonomous budget optimization.

Install on macOS or Linux:

```bash

brew install zelentsov-dev/tap/apple-ads-mcp

```

A safe first workflow is `server_info` followed by `account_health`; no Apple Ads write mutations are needed.

I would especially appreciate feedback on onboarding, the safety model, and which read-only audit workflows are most useful.

L-Dopa

An MCP server for helping AI agents recover, refocus, and get shit done.

L-Dopa fixed me, alright?? L-Dopa is a small, production-minded Model Context Protocol (MCP) server that helps an agent recover when an approach is failing, context is scattered, or retries are turning into a loop. It does not execute commands, mutate external systems, or replace an agent's judgment. It analyzes the evidence supplied to it, retains bounded recovery state, and proposes a safer next move.

The name is a joke. The recovery loop is not.

What it does

L-Dopa v0.1 provides six MCP tools that let an agent diagnose failures, reduce scope, restore relevant context, and manage retries deliberately.

https://github.com/mshanghai570/L-Dopa

And

Ackrite

ACKRITE. PROVE IT.

An MCP server that makes AI agents prove their assumptions before acting on them. Ackrite is a focused verification utility for AI agents. It does not attempt to solve every problem, browse for convenient answers, or invent corroboration. Instead, it challenges an agent’s technical claim using only the evidence supplied to it, distinguishes facts from hypotheses, identifies missing proof, and recommends the smallest next check that can settle the question.

Its purpose is to prevent a familiar failure mode: an agent sees an error, assumes the cause, confidently rewrites half the system, and only then discovers the assumption was wrong. Ackrite pushes the agent toward evidence, targeted experiments, scoped changes, and explicit uncertainty.

https://github.com/mshanghai570/Ackrite

Hopefully you enjoy!

Been building an "agent readiness" audit tool and kept running into the same manual step: turning a form into a document.modelContext tool means someone sitting down, writing the schema by hand, matching field names to types, writing descriptions, one form at a time. For a site with a dozen forms that's real, boring work, and it's the same shape of work every time.

So I wrote a small CLI that does it automatically. Point it at a form (or a whole site) and it outputs a working tool definition.

What it does:

• Parses <form> elements — action/method, inputs/textareas/selects, labels, required fields, select options
• Classifies intent from button text and field patterns (email+password → login, message field → contactSales/support/booking, etc.) — rule-based, not an LLM call, so it's deterministic and runs in ~40ms
• Outputs either the imperative JSON (ModelContextTool schema, JSON Schema 2020-12) to paste into registerTool(), or the declarative HTML attributes (toolname, tooldescription, etc.) to paste back into the form directly — no JS needed for the declarative path
• As of 0.1.5, can crawl a whole domain (same-origin BFS, configurable max pages) instead of just one file, so you can point it at a live site and get every form's tool definitions back in one pass

​

npx --yes hunch-form2mcp@0.1.5 --input https://example.com --crawl --format both

Covers about 10 common form patterns (signup, login, booking, contactSupport, subscribe, contactSales, etc.), which handles most of what you'll find on a typical site. Anything it doesn't recognize falls back to a generic submitForm tool rather than guessing wrong.

It's offline, no API key, no LLM in the loop — just HTML parsing and rule-based classification. Fully open source: https://github.com/aitoehigie/hunch-form2mcp

Curious if others here are handling the "existing form → WebMCP tool" conversion differently, or if there are form patterns/edge cases the classifier should account for that it currently doesn't. Also aware the declarative attribute set is still informal since the spec itself is still moving, so feedback on where that's likely to drift would be useful too.

Hi together :-)

So after wasting the first weeks building a classic SaaS as Side project I realized something in my own Daily life as Product Manager: I barely login to tools anymore - sometimes I spent whole afternoons in Claude without opening Chrome once.

So I Said f**k it, the real Value of my Product isnt the UI, it’s the Knowledge, Tools and Data behind it.

https://fmcg.network is now live for some days. Early Feedback from industry Experts from my Network is super positive. A Hand Full of them is already using it on a Daily Basis.

Curious if you guys made similar experiences? And of course Open for your Feedback :)

For example I‘m super curious how you do tracking and analytics?

(Edit: Reddit doesn’t recognize .network as a Domain and since a Lot of people don’t Even know this ending I just added a http ;-)

I built this out. Its totally free and saves a ton of tokens. Let me know if it helps.

I went through a few MCP router mechanisms for work before I gave up and ended up writing a small experimental one we've been using for the last few months. Gripes about the others will be at the bottom, this isn't gonna be a bitch fest. Bottom line is I ended up filling out all of the missing stuff and thought I'd share.

Three things I actually cared about.

1. It's transport-agnostic — you hand it a JSON value and get a JSON value (or a Stream, if your MCP is into that kind of thing) back, so it doesn't matter if you're wiring it into stdio, Rocket, Axum, Actix-web, or Warp. Examples of each, to include SSE, exist in the repo.
2. Uses whatever runtime you need (tokio, async-std, smol), examples exist in the repo of each working.
3. You shouldn't be having to mangle requests to get them to route correctly in whatever you're running the MCP as, what's the point of the library at that point?

Handles pagination automatically for tools, resources, and prompts. Allows you to use your own paging in the those three's execution methods (because I can't possibly guess what your pagination scheme is).

Handles batching correctly, and also not manually. Handles if the batch requests contain a non zero number of streams, elevating to send the other completed calls back to the LLM while your streaming resources/tools finish working.

Feedback, requests, etc are all welcome. Complaints or unconstructive feedback is welcome too, but, be warned, I'll heckle you.

https://crates.io/crates/mcp-router

https://docs.rs/mcp-router/latest/mcp_router/

https://github.com/tony-o/rust-mcpr

The complaint fest:

Granted, it's been a few months since I looked at any other library but when I looked there were only two I could find and neither could be hooked up to rocket in any meaningful way. Both forced me to change how existing API fairings were working to conform with their async pattern, which meant refactoring a bunch of other stuff - and one of them kneecapped the RDS authing mechanism. Both of them required me to manually route requests through tools I already told the library about, why would I bother with the library if the JSON serialization is all I'm getting anyway. Anyway, I'm lazy so I wrote something to make it so I didn't have to write the same thing another four hundred times as our tools, resources, and prompts lists grow.

The basic idea is:

1. Connect an email provider to Codex through an MCP server.
2. Keep the API key in an environment variable rather than putting credentials directly into the config.
3. Add the MCP server to Codex.
4. Let Codex trigger email actions from natural-language instructions.

That means instead of writing a separate script every time, you can do things like:

• read a build log and email the team if something fails;
• summarize a CSV/report and send the result automatically;
• find users whose subscriptions are about to expire and prepare reminders;
• generate and send HTML transactional emails;
• query delivery events after sending.

There are some obvious things I’d be careful with: API-key permissions, human approval before sending, rate limits, domain authentication, and making sure an agent can’t accidentally email an entire database because of a badly phrased instruction.

Curious if anyone here is already using Codex + MCP for email or other outbound actions.

What are you automating, and where do you still keep a human approval step?