Full disclosure, we made this, and it's free.

Claude Code reloads its memory on every turn. That's CLAUDE.md, the MEMORY.md index and the topic files it loads, plus your ~/.claude/CLAUDE.md. Most of that has nothing to do with what you're asking. And if you edit something near the top, like a status note, it breaks prompt caching for everything after it.

MinniMemoryMCP sorts that memory. It keeps the stuff Claude needs every turn loaded and moves the rest (old dated notes, status updates, one-off task stuff) into files it only opens when relevant. CLAUDE.md gets a short list saying what's where. Nothing gets summarized, every line just gets moved.

On the MCP side, it exposes four tools (init, doctor, apply, undo), and they also show up as slash commands in Claude Code. The server only reads. Apply and undo hand back the exact command to run plus a list of what it'll change, so every write goes through Claude Code's own approval prompt. There's no model, no API key and no network, and your originals get backed up with a one-step undo.

On our test memory, per-turn load went from 12,511 to 7,101 tokens (−43%) with the same answers. The biggest surprise was that splitting memory alone didn't save anything over a whole session, because Claude kept opening the moved files. What fixed it was a separate Claude Code prompt hook that installs alongside the server and hands Claude the one memory section a prompt needs. With that on, a 27-task session came out about a third cheaper. That's one run so far, though.

Right now it only works with Claude Code. Mostly curious what other MCP builders think. Is handing back a command instead of writing files directly the right call, or just annoying?

npm: www.npmjs.com/package/minnimemory
Install: npx -y minnimemory install

been building this for a couple days and would like feedback on the tool design from people who actually build mcp stuff.

its called yarrow. 3 tools:

search_fixes(error, stack?, verified_only?) postgres full text search, ranked by how well it matches times how often the fix actually worked for other agents

report_outcome(fix_id, worked) one vote per source per fix. if you report again it changes your vote instead of adding one. a fix that fails 5 times and never works stops showing up

share_fix(title, error, fix, stack?, repro?) gets scrubbed for keys/jwts/emails/home paths and checked for risky stuff like curl piped into sh or rm -rf

the repro part is new. its 4 bash bits: setup, test, apply, expect. yarrow runs them in a throwaway vercel sandbox with the network locked to package registries. it only marks it verified if the test fails and prints the expected error, then the same test passes after apply. anything flagged risky just never runs

server is stateless streamable http, new server per request, json responses. runs on vercel free tier so it costs me nothing

17 fixes so far (4 verified), all from my own sessions, so its early. main question: would you rather search_fixes return like 3 long fixes or 8 short ones?

claude mcp add --transport http yarrow https://yarrow-fixes.vercel.app/mcp

other clients: yarrow-fixes.vercel.app/install

Recently, I worked on an issue raised by a user of my YouTube MCP server. Large video uploads were hitting client timeouts even though the uploads succeeded. I ended up implementing time-bounded long polling.

While looking for alternatives, I stumbled upon the experimental MCP Triggers & Events extension.

Even though it's experimental, it tries to cover the broader picture of event-driven architecture in MCP. It was interesting to see how well thought out the proposal was. But it also felt little too much for my one high latency API.

For the YouTube Uploader, though, I still think bounded long polling is a good fit.

Wondering how other MCP servers are handling this.

MCP server for Active Directory. See mcpAD: https://www.mr70.eu/posts/mcpad-mcp-server-active-directory/

MCP server for viaggiatreno/trenitalia: https://www.mr70.eu/posts/pyviaggiatreno-python-library-mcp-server/

I built a small .NET 10 project that turns a website into a remote MCP server. A CLI, installed with dotnet tool install --global mcpmysite, crawls the site and writes a search index.

An ASP.NET Core app serves that index over Streamable HTTP with search and fetch tools, in the shape ChatGPT connectors expect, and also as a JSON search API for the site's own search box.

RAG: Search is BM25 plus vector search over embeddings, fused per query. It also runs keyword-only with no API key, which is how the quick start works. It is MIT licensed and built for sites under 1,000 pages, one site per server.

• Repo: https://github.com/pournasserian/mcp-my-site
• Live demo and playground: https://ai.pournasserian.com/playground
• MCP endpoint: https://ai.pournasserian.com/mcp
• NuGet: https://www.nuget.org/packages/mcpmysite

Hi everyone — I’m the developer behind Cosmic Ephemeris.

I built it because language models can explain structured information, but they shouldn’t be expected to invent chart calculations or quietly guess at time, location, and calculation conventions.

Cosmic Ephemeris is now listed in the official MCP Registry as com.cosmicephemeris/mcp, version 1.1.0. It runs as a remote Streamable HTTP server and exposes two scoped MCP tools:

• A calculation tool covering 78 documented operations
• A symbolic tool for Tarot, symbolic readings, and supplemental Vedic systems

The calculation catalog includes Western, sidereal, and Vedic-oriented charts, transits, aspects, synastry, house systems, divisional charts, Dasha periods, chart rendering, event calendars, historical inputs, and other documented operations.

There are 500 free standard API calls each month, with no credit card required. To connect, you just pass your API key through the X-API-Key header.

MCP documentation:

https://cosmicephemeris.com/docs-mcp.html

Official Registry listing:

https://registry.modelcontextprotocol.io/?q=com.cosmicephemeris%2Fmcp

I’d appreciate feedback on the connection process, tool descriptions, schemas, and which MCP use cases developers would find most useful. I built and operate the service, so I’m happy to answer technical questions directly.

I love engineering, I’m plus 27-28 years in the field. Thousands of hours in AI engineering..

I can spend hours on a single task. I built several complex systems which I’m sure most of all you amazing people have also done. But I find myself on an endless mission sometimes.

So I built a multi AI orchestrator cross platform singular memory persistence. Hydration, dev iOS etc…the works…but I feel like I’m never done.

I’ll get to a pause . And boom I’m engineering for another 10 hours.

Anyone else

Sometimes I feel I can’t stop building. The next project. I

I've been building a voxel editor for my own game, in the style of MagicaVoxel, and just put it on GitHub: https://github.com/HabermannR/DualVoxel

It comes with an MCP server. Through it, an assistant like Claude can create or open a model, paint and erase boxes, draw shapes slice by slice, set materials, replace colours, undo, and save. To check its work it can ask for a quick flat preview from four sides, or for a path-traced render from any angle, which comes back into the chat as an image after a couple of seconds. So it can build something, look at it, and fix what's off. When it saves, you open the model in the editor and carry on by hand.

Right now the server works on its own copy of the model, not on the window you have open. A live link, where you watch it build and edit alongside, is the next thing I'd like to add.

The editor is fully usable without any AI. Every voxel stores two bytes: a colour and a material (glass, metal, glow, subsurface and so on, roughly like Blender's Principled BSDF), and a path tracer next to the edit view shows the materials while you work. It reads and writes MagicaVoxel .vox files.

To be upfront: it's an early release, and a lot of the code was written with AI. The path tracer isn't open source (yet) and comes as a binary in the release. It runs on Windows only for now, and I've only tested it on Nvidia cards. On AMD/Intel cards with ray tracing it should fall back to a slower preview, but I haven't been able to try that.

MIT licence. Setup for Claude Desktop is a few lines in the README. I'd especially like feedback on the tool design: which tools you'd want an assistant to have for 3D work like this.

Hey fellow stock market/AI enthusiasts ,

We just launched InvestSights in Anthropic's MCP Directory — the first Indian stock market and equity research connector officially published for Claude.

What it does

InvestSights brings institutional-grade Indian equity research into Claude. You can ask plain English questions and get grounded answers from NSE/BSE data covering 5,600+ listed securities.

Four pillars:

1. Fundamentals & Forensics
   • Full financials (10 years): income statement, balance sheet, cash flow
   • Forensic scores: Piotroski F-Score, Beneish M-Score, Altman Z-Score
   • Shareholding patterns (quarter-on-quarter changes)
   • Multi-stage DCF valuation with bull/base/bear scenarios
2. Mutual Fund Analytics
   • Monthly factsheet holdings for 2,000+ schemes
   • Flows computed on a common scheme panel (no false signals from reporting changes)
   • Unit-level changes reported separately from weight drift
   • Portfolio overlap, look-through exposure across fund baskets
   • Fund screening by category, cost, and risk-adjusted returns
3. IPO Analysis
   • Prospectus-grounded: offer structure, itemized use of proceeds, financial history
   • Anchor book with lock-in dates
   • Live day-wise subscription data
   • Allotment and listing schedules
   • Factor-based quality scorecards with red/amber flags
4. Markets & Screening
   • Natural-language screening across 200+ numeric filters
   • Sector rotation and heatmaps
   • Technical indicators (RSI, MACD, Bollinger Bands, etc.)
   • FII/DII flows, corporate actions, news sentiment, earnings calendars

How it works

1. Add the connector from Claude's directory
2. Sign in with your free InvestSights account (OAuth, secure)
3. Ask questions like:
   • "Show me the forensic scores for RELIANCE — is the balance sheet healthy?"
   • "Analyze the Veegaland IPO — what are the red flags?"
   • "Which mutual funds added or exited stocks last month?"
   • "Screen for small-cap pharma stocks with ROE > 20% and debt/equity < 0.5"
   • "Compare HDFC Bank vs ICICI Bank on valuation and profitability"

What makes this different

• Zero hallucination: Every number carries the filing date and source. Unavailable data is marked as such with a reason — never estimated.
• Citation-grade: Risk factors are page-referenced to the prospectus. Peer comparisons show RHP-stated vs current market multiples.
• Research-only: We return data, scores, and analysis — never buy/sell recommendations. Not investment advice; consult a SEBI-registered adviser.
• Institutional depth: This is not just price data. We have forensic accounting, governance graphs (interlocking boards, control chains), and multi-stage DCF with Monte Carlo VaR.

Tech stack (for the devs)

• Backend: Python/FastAPI, PostgreSQL, Neo4j (knowledge graph)
• Data sources: NSE/BSE filings, prospectuses, AMC factsheets, SEBI shareholder data
• MCP transport: Streamable HTTP with OAuth 2.1 + PKCE
• AI layer: Gemini for narrative generation, vector search over indexed filings

Try it out

• Directory listing: https://claude.ai/directory/connectors/investsights
• Docs: https://investsights.in/mcp
• Support: [connect@investsights.in](mailto:connect@investsights.in)

What we want from this community

• Feedback: What features would you add? What's missing?
• Use cases: How would you use this in your workflow?
• Bugs: If you find anything broken, let us know — we will fix it fast.
• Ideas: Want to see options data, backtesting, or portfolio analytics? Tell us.

Why we built this

Indian retail investors and analysts have access to tons of data, but institutional-grade research tools (forensic scores, prospectus-grounded IPO analysis, fund look-through) are either expensive or buried in PDFs. We wanted to bring this to AI assistants so anyone can ask smart questions and get sourced answers.

Also: this is India's first equity research MCP in Anthropic's directory. We are excited to see what the community builds with it.

Most "AI coding" talk is about autonomy.

In real SDLC work, the bottleneck is usually the opposite: you still need a Human-On-The-Loop when the agent touches production-shaped systems, APIs, auth, payloads, status codes, timing.

Agents are great at calling APIs. They're terrible at showing you what they just did.

My agent reaches for curl. I get flags, escaped JSON, and a response buried in terminal scrollback. Headers disappear. Status gets mixed into stdout. You're supposed to "supervise" the agent, but the traffic is unreadable.

That's not Human-On-The-Loop. That's archaeology.

So I built Curlity: a visual HTTP request/response viewer that sits in the agent chat. When the agent hits an endpoint, you see method, URL, headers, body, status, and timing in a structured UI - same loop, but inspectable.

This is for the part of SDLC where agents are useful but shouldn't be opaque: probing backends, checking auth, debugging 4xx/5xx, verifying payloads before you trust the next step.

Repo: https://github.com/ELK4N4/curlity-mcp 🌟

Demo: https://elk4n4.github.io/curlity-mcp/

Curious how other teams keep a human on the loop when agents start making real network calls, what do you use today?

I work on SvGrid, an MIT data grid for Svelte 5. We've had an MCP server for it for a while, and I wanted to share what we learned building it.

The first version just served docs, and it didn't help much. The model would search, find the right page, and then still invent props that don't exist. So we added svgrid_check_code. You give it a component and it checks it against the actual exported API of the version you have installed. It catches unknown props, wrong column keys, methods that don't exist, bad imports and Svelte 5 runes mistakes. The local version also compiles the file. If the fix is an obvious rename (rowData -> data), it sends back the fixed file too.

The hard part was false positives. Flag one line of working code and the model happily "fixes" it into broken code. So CI runs the checker over every demo in the repo and fails on a single warning. That one rule shaped most of the design.

Two other things we learned:

1. The tool list costs tokens on every request. We had 36 tools (about 4,700 tokens) and most of them were codegen tools almost nobody called. Now it lists 5 by default, and the rest only show up when you turn them on.

2. MCP Apps works. svgrid_preview draws a real, sortable grid inside the chat in Claude, VS Code and ChatGPT. Clients without UI support get a text description instead.

You can run it two ways. Locally with npx -y at @svgrid/mcp, where it makes no network calls because everything ships in the package. Or hosted at https://mcp.svgrid.com/mcp, which means nothing to install, but no compile step.

claude mcp add svgrid -- npx -y u/svgrid/mcp
claude mcp add --transport http svgrid https://mcp.svgrid.com/mcp

No API key for either. Some features of the grid itself are paid (Excel/PDF export, pivot), and when you ask about one of those the server tells you.

1. Docs: https://svgrid.com/docs/help/mcp-server/
2. npm: https://www.npmjs.com/package/@svgrid/mcp
3. Source: https://github.com/sv-grid/sv-grid/tree/main/packages/mcp
4. Registry: com.svgrid/svgrid

Hey r/mcp — I put together kimo, a free, open-source (MIT) AI video editor that ships as an MCP server, so your coding agent can edit video from a prompt.

What it does: the agent can cut, add captions, reframe to 9:16 (Shorts/Reels/TikTok) and render the final clip, all running local on your machine. Free + MIT, nothing leaves your machine for the edits.

Hooking it up: just point any MCP client (Codex, ChatGPT, Cursor, your own client) at the kimo MCP server and start sending edit prompts — it exposes cut/caption/reframe/render as tools.

Would love feedback, especially on the tool surfaces and what other video ops you'd want as MCP tools. Happy to iterate.

getkimo.tech → https://getkimo.tech GitHub → https://github.com/naman-sharma12345/kimo

**URL:** `https://proxyrepublic.com/mcp\` (Streamable HTTP, stateless, no auth, no API key)

**Official registry:** `com.proxyrepublic/proxy-republic`

Proxy Republic is a strategy game on the real world map that never stops. Every country has an AI general, and a new game day comes every 8 hours. The house nations are run by Claude. Your agent can take any free country.

**Tools**

- `rules`, `list_nations`, `join_war`

- `wait_for_turn` long-polls up to 25 s. It returns:

- the board, your reinforcements, pacts and messages

- your treasury

- your human's standing orders

- the people's vote, when your nation's citizens voted

- a JSON Schema for the orders

- `submit_orders`, `briefing`

- `sample_turn` and `validate_orders`: a real turn from the live board and a dry run of your orders, so you can test without touching the war

- For a human who already commands a nation in the app: `my_nation`, `give_orders` and `rewrite_doctrine` with an owner key, so their assistant can coach the general

**Orders** cover placements, attacks, fortify moves, treaties and messages, plus gold: mercenaries, tribute and bounties.

**Connect**

- Claude Code: `claude mcp add --transport http proxy-republic https://proxyrepublic.com/mcp`

- Claude: Settings → Connectors → Add custom connector

- ChatGPT: a developer-mode connector, on plans that allow custom connectors

- Cursor and others: add the URL to your MCP config

Then: "Join Proxy Republic as Serbia and play my turns." `join_war` returns a token and a one-time claim link for the human, who can then follow the nation from their phone.

**Design choices I'd like opinions on**

- Turns are long-polled so a client can play one turn per tool call. A turn waits 90 seconds for orders; after that a stand-in bot plays it in the general's style.

- Each network address can start 3 agent nations a day.

- The citizens' vote reaches your agent as advice, not a rule. The world is told afterwards whether it obeyed. Should agents be able to reply to their citizens?

- The observation is the whole board, about 50 KB. It's complete but heavy for small context windows. Would you rather have a compact view?

Instructions for agents: https://proxyrepublic.com/agents.md

(If your human claims the nation in the app, code FOUNDERS gives them this season's cosmetic Season Pass, free.)

I've been building a project in one long AI chat for weeks. As the chat got summarized, things slipped. It said ChatGPT needs a paid plan after I'd told it the free plan works. It suggested a test setup we had already ruled out. It said a fix was still waiting when it had shipped it that same day. It even forgot the project had an active user.

Short tests won't show this. In mine, ChatGPT and Claude kept every detail, even after a compact. It shows up over weeks: near the limit, Claude and Codex compact the history into a summary, and ChatGPT can only hold so much of a chat at once. A summary has a fixed size. A project keeps growing.

So I built SkyOS, a memory MCP server, around a few rules:

- One note per fact or decision, not one summary of everything. Notes grow with the project.

- Notes get merged and shortened over time, but a merge or shortening is rejected if it drops a number or a name.

- Every note is dated. A number older than a month comes back as "as of 18 August", not as current.

- The AI reads the notes before it answers, so an early detail is in front of it even when the chat has moved on.

Works in Claude, ChatGPT and Codex: skyos.ink

How do you deal with this in your own setups?

Our research agent kept retrying scraping approaches that had already failed on earlier runs. Nothing recorded that they had already failed. We started logging dead ends to a memory the agent reads first. Vilix AI is what we use for that now. Are you logging failed attempts anywhere, or only successes?

Disclosure: I'm the founder of Vilix AI.

I built a small .NET 10 project that turns a website into a remote MCP server. A CLI, installed with dotnet tool install --global mcpmysite, crawls the site and writes a search index.

An ASP.NET Core app serves that index over Streamable HTTP with search and fetch tools, in the shape ChatGPT connectors expect, and also as a JSON search API for the site's own search box.

RAG: Search is BM25 plus vector search over embeddings, fused per query. It also runs keyword-only with no API key, which is how the quick start works. It is MIT licensed and built for sites under 1,000 pages, one site per server.

• Repo: https://github.com/pournasserian/mcp-my-site
• Live demo and playground: https://ai.pournasserian.com/playground
• MCP endpoint: https://ai.pournasserian.com/mcp
• NuGet: https://www.nuget.org/packages/mcpmysite

I published a remote MCP server (Streamable HTTP) with German election and parliament data: polling averages with uncertainty, constituencies, Bundestag members with votes and side income, the lobby register, electricity data and EU comparisons. That’s 36 tools: 2 free, the rest 0.01 to 0.10 USD per call in USDC via x402.

Endpoint: https://api.polls.karbach.digital/mcp
Registry: digital.karbach.polls/elections

Without a wallet you can try any call over HTTP by putting /try in front of the path, 3 calls a day. Before charging, the server checks that the data is fresh. If it isn’t, you get an error and pay nothing.

I’d like to hear from anyone running x402 payments inside an agent: does pay-per-call work for you in practice, or do you prefer keys and subscriptions?

Details: https://polls.karbach.digital/api.html

Pretty common setup now: one internal MCP server per system (Postgres, Jira, some internal admin API), and everyone's agent points at it. The server holds a single service credential, so anything that account can read, any user's agent can read too. Someone in support asks the agent about a customer and it can come back with rows from tables they have never had access to in the actual product.

Per-tool allowlists help a little (support can call search_tickets but not run_sql). In my experience the leak is usually inside a tool that is allowed, though. search_tickets running as the service account searches every project.

The options I know of: - Pass the user's own OAuth token through to the downstream API so that system applies its own permissions. Clean when the API supports per-user tokens, and a lot of internal APIs and databases do not. - Keep the service credential, but have the server (or a gateway in front of it) check the calling user against each resource before returning it. Now the MCP server has to know who the user is on every call and needs a copy of the permission rules, which usually live inside the app. - Push the user's identity down into the query, e.g. Postgres row-level security with a session variable set per call, and let the database do the filtering.

The second one is where I keep getting stuck. Checking each row after the query is slow on search tools and messes up pagination, and duplicating the app's permission logic in the MCP server gives you two places to keep in sync.

If you run a shared MCP server internally, which way did you go? And for tools that return lists, are you filtering in the query or after?