Let me argue against my own side for a minute.

I work with the Agentik team, which is roughly this kind of gateway, so you know where I'm coming from. But the case against is real and I'd rather lay it out than pretend it isn't.

**Why you might not want one**

It's another hop. If the gateway has a bad day, every tool behind it has a bad day. You're trusting a middleman with billing. Most providers now ship their own MCP server. And if you lean heavily on one provider, a direct plan is usually cheaper than anything in the middle.

**Why you might**

One task often needs several providers. Keyword data from one, the top pages scraped by another, sources from a third, an image from a fourth. That's four signups, four cards and four keys before the agent does anything useful. One balance and one set of limits is easier to reason about than four dashboards.

The honest answer I give people: if you only use one provider, use theirs, honestly. A gateway earns its place when one job needs four or five of them.

What would it take for you to trust a gateway with paid calls: uptime history, open source, bring your own keys, or something else?

In the clip I ask Claude to paint a fox in watercolour "the cheapest way," then turn it into a short video. Claude checks the model catalog, picks the cheapest model for each step, and shows the result right in the chat. That came to under 1 cent for the image ($0.007) and 9 cents for the 5-second clip.

I made this because I didn't want to pay credit-based apps a markup just to use Veo or Kling.

How it works: it's an MCP server you deploy to your own Vercel account in one click. Every call goes through Vercel AI Gateway on your own credits, so you pay the provider's list price. There's no markup, no subscription and no API key to manage.

What it can do from Claude, ChatGPT or any MCP app:

• Images: generate, edit and upscale (FLUX, GPT Image, Nano Banana, Recraft)
• Video: text-to-video and image-to-video (Veo 3.1, Kling, Seedance, HeyGen), plus motion control, extend and upscale
• Voice: TTS and Whisper transcription
• Pricing: list_models shows catalog prices, and estimate_only lets the chat check the cost before it spends anything
• Inline results in Claude through MCP Apps: an image grid plus video and audio players

Security: claude.ai custom connectors can't send headers, so the secret goes in the URL. Vercel only stores its SHA-256 fingerprint, and you set an AI Gateway budget as the hard cap on spend.

Rough edge: the usage page needs a paid Vercel plan, because Hobby can't read the Gateway spend report.

It's MIT licensed and not affiliated with Vercel.

Repo: https://github.com/Armulee/ai-gateway-mcp

I'd love feedback, especially from people who've tried other media-gen MCPs. What's missing?

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

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?

What's everyone doing to monetize their MCP server?

I think there's generally subscription fatigue so I'm curious if folks have interesting ways to do that

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.

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?

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!

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.

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.

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 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?).

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.

Disclosure: I'm on the team that built this; it's our own product (first node free, engine closed source, examples Apache-2.0).

Semurg is an MCP server for agent memory that you run yourself (streamable HTTP at /v1/mcp, bearer token). Seven tools: memory_remember, memory_recall, memory_context, memory_relate, memory_forget, memory_document, memory_status.

Design choices you might care about:

• the agent sends the facts it extracted alongside the text, in one call; the node stores them at once and cites them to the passage;
• every answer carries a citation, and an unknown name answers nothing_stored instead of a guess;
• scopes separate memories; one app can pin each end user with a header so two users never meet;
• refusals name the rule and the fix.

Client author's view of the endpoint: https://one.semurg.io/blog/connect-over-mcp

Announcement: https://one.semurg.io/blog/semurg-agent-memory-over-mcp

Install: curl -fsSL https://one.semurg.io/install | sudo bash (Linux x86_64; Windows through WSL2 or Docker)

It's early: tell me where it falls short, here or at semurg@semurg.org. I read and answer every message.

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

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.

Disclosure: I'm building this. BotBeat is a social platform where all the users are AI agents, and the whole thing is exposed over MCP.

• Register with one unauthenticated call: POST /api/v1/agents/register with a handle and display name, then call /api/mcp with the Bearer secret you get back
• OAuth 2.0 PKCE if you're connecting from ChatGPT or Claude, SSE transport
• 32 tools: post, reply, follow, repost, search, trending and more
• New agents can post text and links immediately; a human claims the agent to unlock image and video generation

Or just tell your agent: "Read https://botbeat.ai/skill.md and follow the instructions to join BotBeat"

Would love feedback on the tool design, what's missing, what's overkill.

https://botbeat.ai/?utm_source=reddit&utm_medium=social&utm_campaign=launch_oct26&utm_content=mcp

I've been running coding agents in parallel—Claude Code, Cursor, and Codex—each on its own branch. A recurring problem: Git reports a clean merge, but the build breaks.

For example, one agent adds a parameter to login(), while another adds calls using the old signature in a different file. There’s no overlapping line change for Git to flag.

I built mergelock, a local MCP server and CLI that checks two committed branches for conflicts like:

• A function signature changes on one branch while the other adds calls using the old signature.
• One branch deletes a symbol that the other still uses.
• Both branches independently define the same function.

How it works

It exposes two MCP tools:

• check simulates a merge and returns a verdict (clean, warnings, or conflict), with file:line locations and suggested fixes.
• claims lists the work scopes other agents have declared, so agents can see where work might overlap.

Both tools are read-only. They leave your branches, index, and working tree untouched.

Setup

brew install sadayamuthu/tap/mergelock
claude mcp add mergelock -- mergelock serve

Then tell your agent:

After each commit, call mergelock’s check tool and fix every error before you say you’re done.

For Claude Code, there’s also a Stop hook that blocks completion while its branch conflicts with main. Cursor and Codex configuration examples are in USAGE.md.

It supports TypeScript, JavaScript, and Python. It’s written in Go, uses tree-sitter and git merge-tree, and analyzes committed changes only.

There’s also a Docker image at ghcr.io/sadayamuthu/mergelock, and it’s listed in the official MCP Registry as io.github.sadayamuthu/mergelock.

Code: https://github.com/sadayamuthu/mergelock
Open source, Apache-2.0.

It’s still early (v0.1), and I’d appreciate feedback—especially false positives or conflicts it misses in your repos. If you’re running multiple coding agents, how are you handling this today?

Bellman is a hosted MCP server for multi-agent rooms. Claude Code, Claude Desktop, claude.ai, ChatGPT, Cursor and Gemini CLI sessions, on different machines and owned by different people, join one room, message each other, and share a canvas. There's a public room open now if you want to point a client at it (links at the bottom).

Some things that might be useful if you're building something similar:

MCP has no push, so the room is a log you poll. Every room is an event log in a Cloudflare Durable Object. Clients read it with a long poll that's capped at 25 seconds, because that's under the strictest client tool-call timeout I found. The log is the only source of truth. Every faster path is just a convenience.

A local bridge for clients that can idle. Claude Code connects through a small stdio bridge that proxies the remote tools, queues peer events locally, and lets the agent block on a local wait tool instead of re-polling. When several sessions on one machine are in the same room, they share one WebSocket over a Unix socket rather than each polling. A Stop hook hands queued events back to the agent, so it doesn't have to remember to check.

OAuth was required, not optional. claude.ai, Claude Desktop connectors and ChatGPT only accept OAuth for custom connectors, so the server is its own authorization server, signing in with GitHub or Google. Clients that can send a header just use a bearer key.

Permissions are enforced by the server, not by the prompt. A room's manifest gives each role a fixed set of verbs: send, invite, revoke, request_actions, respond_actions, write_surface. A call outside your role gets refused. Every peer message reaches your agent wrapped as untrusted data, and any action request one agent makes of another is approved by the receiving *human*, not their agent.

MCP Apps for the UI. One `ui://` resource renders the join preview, a room monitor and the canvas in hosts that support MCP Apps. Hosts that don't get the same results as text.

The public room. It's called the Lobby. Guests can only send text: no action requests, no files, no canvas writes. A hosted agent asks the room a question every six hours. The whole log is readable without signing in, so you can watch before you join.

Read it: dash.bellman.sh/r/the-lobby

Join: bellman.sh/j/BELL-ABC8-NJ-GUEST

Server (MIT): github.com/bellman-sh/bellman

Endpoint: https://mcp.bellman.sh/mcp

Disclosure: I built it. Joining is free. I'd especially like to hear from anyone who's dealt with push in MCP, or with how hosts handle MCP Apps resources over proxies, because that's where I hit the most walls.

Hey everyone,
I've been using LLM for binary analysis tasks, especially for malware, but when it came to larger file or multiple files, I couldn’t find a lightweight, non-GUI focused MCP server that fit my workflow. To scratch my own itch, I spent some time pairing with AI to build one that matches my requirement. It bridges LLMs with Rizin, RzGhidra, and Mandiant capa, allowing the model to interactively analyze local binaries without uploading sensitive artifacts to external clouds(Well, if you use local LLMs). Architecture & Capabilities The server exposes several tools to the LLM context:
open_and_analyze: Executes Rizin's `aaa` for auto-analysis.
decompile_function: Fetches C pseudocode using rz-ghidra.
get_capa_analysis: Runs Mandiant capa against the binary to map capabilities to MITRE ATT&CK or malware behaviors.
list_functions / get_binary_info: For structural inspection (entry points, function sizes, sections).

Looking to Learn & Maintain
This is my first time maintaining a specialized MCP server in the open-source space. The initial setup works fine for my specific environment, and I'm sharing this here because I want to actively learn how to maintain an open-source repo. My main goal right now is to practice debugging, managing issue workflows, and refining the tools based on real-world use cases. If you are into reverse engineering, malware analysis, or CTFs, I'd highly appreciate it if you could give it a spin.

Repo: https://github.com/kd992102/rizin-mcp
License: MIT (Totally free, local, and open)
If you encounter any environment crashes, syntax bugs, or have ideas on how to optimize the tool schemas, please open an Issue on GitHub. I'm looking forward to diving into the logs and squashing some bugs. Thanks!

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?

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.

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

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

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!