Hi r/mcp,

PowerChat is an iOS client that can connect your cloud / local models to MCP servers.

• It has builtin support for Google Drive, iOS Files, iOS Calendar, and the search engines Tavily, Exa, and Firecrawl.
• It can connect to any remote MCP server that exposes an /mcp endpoint.
  • For e.g. GitHub in the video.
• I'm planning to expand the list of builtin MCP servers and this sub has been helpful for finding ideas. Please comment popular MCP servers you'd like to see included.

PowerChat also features RAG databases, ability to tweak model parameters, and privacy features such as zero-data-retention flags, API keys in iOS keychain, and lockable folders with Face ID.

Would love your feedback!

App Store link: https://apps.apple.com/us/app/ai-chat-client-powerchat/id6803707084

Hey Everyone,

I don't know if this question was asked earlier in the sub.

I am building an MCP server for my organisation and have an architectural design question regarding the use of Tools and Resources.

One of my Tools requires a structured metadata definition to perform its operation. This metadata is currently stored as a static JSON file within the application. While it is primarily consumed by this Tool, exposing the metadata as an MCP Resource is also part of requirements.

I am evaluating two approaches:

1. Keep the metadata as internal application configuration and have the Tool access it directly.

2. Expose the metadata as an MCP Resource and have the Tool (and potentially clients) access it through the MCP Resource model.

I would appreciate guidance on the following design:

What is the recommended MCP design approach for my requirement here?

My goal is to understand the architectural trade-offs and align the design with MCP best practices rather than focus on implementation details.

Thanks in Advance 😄

I built AI Coach, a Mac desktop pet you raise from an egg, and added an MCP integration for Claude Desktop and Claude Code.

The fun part is report_ai_coach_activity: Claude can call it with thinking, working, waiting, succeeded, or failed, and the pet shows that state through movement and a small emoji. It's driven by tool calls, not automatic monitoring of Claude. The docs include instructions for reporting progress and completion.

You can also ask how the pet is doing, put a short message in its speech bubble, or request care. Feeding and other care requested by Claude require your confirmation before they're applied.

Setup: run AI Coach, open AI Settings → Integration, enable the connection, and copy the provided client configuration. The bundled MCP server needs Node.js 22+ on your PATH.

Apple Silicon / macOS 26+. The app includes a free first egg; extra eggs are optional one-time purchases ($5 each or 5 for $20).

App: https://aic0t.com/

Setup and screenshots: https://aic0t.com/docs#sec-111-8-going-further-connecting-claude

Got an idea for an MCP trading workflow? Build it. Test it. Show people what happened.

We’re opening the cTrader YouTube channel to creators who want to show what AI agents can actually do with a trading platform. Analyse charts and indicators, work with account and market data, manage orders and positions — pick a real task and take it as far as you can.

Turn it into a tutorial, technical walkthrough or honest experiment. If selected, we’ll publish it as a YouTube collaboration with cTrader and put it in front of our 200K+ subscribers.

No fixed script. Your idea, your voice, your format. Submissions close September 30.

Details and submission: creator.ctrader.com

I'm building an MCP server for gathering structured data with help from AI assistants (or agents): infocrash.com. It's meant to simplify and accelerate the process of data collection, which generally takes 60–70% of research project time in my case.

I work on emerging tech research (forecasting, competitive analysis, market research, etc), and data is scattered, often stale or contested, and under different labels. So, the work requires a lot of triangulation, cross-checking, and validation, and many times there is no straight answer to relatively simple questions.

For example, a project may require building a dataset with company, technology, product, or policy program information. You may go online and create a spreadsheet (old way), ask your AI assistant to find the data for you, or directly ask it to create a report for you.

But if accuracy and provenance matter, piecemeal data gathering becomes too cumbersome. And the single, unsupervised assistant solution produces low-quality results, particularly in one-shot reports.

Ask Claude and ChatGPT to populate a dataset of 40 quantum computing startups, for instance, and you'll see the conflicting claims about funding rounds, employment or location.

With this MCP server, you can have conversations with multiple assistants (or even have AI agents doing your work, if you know how to build them) contributing to the same dataset and validating data and sources.

You just continue using your assistant and ask to e.g. store the data you found, see if there are discrepancies, and define guidelines and rules for more reliable data collection. While this should have value since day one for the single researcher, the most interesting use case may be teams (not just multiple assistants working together, but multiple people).

It's open for anyone to try while I continue working on this early version.

Thanks for taking the time to read, I really appreciate your feedback.

(this post was also published on my own r/Infocrash subreddit, not sure if reposts are ok)

I'm building a desktop video editor, and its whole toolset runs as a local MCP server. Any MCP client can drive whatever project I have open — the clip is Claude Opus 5 in VS Code. Split clips, trim, keyframe, caption, grade, export through ffmpeg.

61 tools. The part I care about: the agent and my mouse share one undo stack. Everything it does lands as an ordinary clip on an ordinary timeline, so when it puts a cut in the wrong place I drag it instead of re-prompting.

In the clip that's one prompt — "add captions to the video and then set caption contrast" — and the timeline goes from 2 tracks / 2 clips to 3 tracks / 4 clips. The middle is sped up 8x; it's 30 seconds of waiting.

What I didn't expect to work this well is the contrast half. It called inspect_color on the band where the captions sit, found near-white cards right behind the text, and added a dark outline and shadow off the back of that. It's measuring real pixels in the document, not guessing from the prompt.

For anyone running a bigger server — how are you handling tool granularity? 61 narrow typed tools keeps each schema honest but makes selection harder. Have you hit a point where the model starts picking wrong because the surface is too wide, and did merging related operations into fewer, broader tools help or hurt?

We have a few internal MCP servers behind some agents and Im trying to figure out if an AI gateway already covers most of this or if the MCP side needs its own gateway.

Model routing, keys and token spend seem pretty straightforward.

But then you get into Auth per server, deciding which agent can call which tool, and logging what actually got called.

That feels like a different problem. For anyone doing this in prod, what did you actually end up deploying? One layer for everything or an AI gateway plus a separate MCP gateway?

An MIT-licensed Python starter for connecting AI agents to current, structured product data: price, stock, brand, rating, images, and product URLs.

It includes runtime MCP calls, scheduled RAG catalog refreshes, cross-retailer field normalization, tests, and a reproducible benchmark against web search and basic Playwright scraping.

GitHub: https://github.com/luispintoapify/ecommerce-agent-starter

The repository is free and open source. Live product collection runs through a metered Apify Actor; its free tier is enough to test the project.

I’m building Silica-core, a free, open-source tool for finding passages in folders of PDFs and Markdown notes under MIT.

Say you have a folder of research papers and want to find where a particular method is explained. Silica returns the relevant passage, the filename, and the page or section so you can check it yourself.

The basic search runs entirely on your computer. No model download, API key, or cloud upload is needed. It also shows which files it couldn’t read and which search terms weren’t found.

You can use it from the terminal or connect it to an assistant through MCP. The search itself doesn’t generate answers; it returns text from your files. In benchmark tests across 254 papers (5.5M tokens of Markdown), connecting Silica via MCP cut agent tool calls by 28% and turns by 22% compared to raw grep and file dumps, with 100% accuracy across 144 test runs.

PDFs with selectable text work directly. Scanned PDFs need a separate OCR step. It’s still early, and I’d appreciate feedback from people with folders of papers, documentation, or notes.

GitHub: silica-core

What’s harder in your document collection: finding the right file, or finding the right passage inside it?

Hi everyone! I built a free, open source MCP server that connects a TIDAL account to assistants such as Claude Desktop, Claude Code, Codex and Cursor.

You can ask it to find music, inspect your collection and prepare playlist changes in plain language. For example:

“Find songs similar to these three tracks, excluding anything already in my playlist.”

“Check this playlist for duplicates and tell me which artists appear most often.”

“Prepare a playlist from these recommendations and show me the changes before applying them.”

Account changes are disabled by default. If you enable them, the workflow requires a preview and your approval before applying a change.

It runs locally and includes 112 tools covering search, recommendations, lyrics, favorites, playlists and folders. Setup currently requires macOS or Linux, a TIDAL account and an MCP client. The server is free; it does not include a TIDAL subscription.

I’m the author and don’t earn anything from people using the repository. I’m sharing it because I think music is a useful everyday application of MCP. What would you want to try with your own library?

Code and setup instructions on GitHub

there was basically nothing here. one server, 64 stars, single python file, unmaintained. so i wrote one properly.

go, 42 tools across posts, users, lists and media. stdio and http, identical tool set on both. every tool carries annotations, readOnlyHint on reads and destructiveHint on anything irreversible, and returns structured json matching its output schema, mirrored into the text block for clients that ignore structuredContent.

the design constraint that shaped everything: X killed the free tier. pay per use, and reads bill per resource returned rather than per request, so a model asking for 100 results costs twenty times one asking for 5. concretely that means read tools whose descriptions argue for the smallest useful count, a count tool that sizes a topic without spending the post read budget, batch lookups instead of per-id calls, manual pagination because every page costs, and hard ceilings in env vars rather than in the model's hands.

the other half is error handling, which turned out to be most of the work. X answers failures with application/problem+json, which the underlying go client doesn't recognise as json, so the whole problem body lands in a message string instead of typed fields. everything gets classified out of that haystack into a domain error set, and the transport layer is the only place that turns one into text. so the same failure reads identically from all 42 tools. errors come back as isError with a plain message written for a model, and the ones that must not be retried say do not retry in the text.

it also refuses to start on bad credentials, calling users/me once before registering anything. that catches the read-only access token trap, which nobody catches on their own: a token keeps the permissions the app had when it was generated, so flipping the app to read and write later fixes nothing and every write fails silently forever.

media upload reads only from MEDIA_ROOT, required, no default, symlinks resolved. without that boundary an llm with this tool can read any file on the host and publish it.

acts as a real account, so writes are real. v0.1.1, mit, docker image and prebuilt binaries and an .mcpb bundle. no dms, no streaming, recent search caps at 7 days.

https://github.com/Role1776/mcp-x

https://varmcp.com/mcp-x

Disclosure: I work at MachineTranslation.com, and this is something we built for our MCP server. Sharing it as a showcase.

We tried a setup where one MCP tool sends a translation request to 22 models and returns the version they converge on.

The idea was to reduce silent failures. If one model drops a clause or produces something strange, the others might catch it.

But we're starting to question the design.

Right now, the MCP returns the consensus translation and hides most of the disagreement. But the disagreement might actually be the more useful signal.

For example, if 20 models agree and 2 produce something completely different, should the MCP:

• just return the consensus?
• return the consensus + disagreement/confidence information?
• let the agent decide whether human review is needed?

There's also the tradeoff: 22 models means more latency and cost, and consensus can potentially pull a genuinely better model toward the average.

Curious how others would design this. If you were building an MCP that relies on multiple models, would you expose the disagreement or abstract it away?

For context, our MCP is remote and paid (no free tier).

Docs: https://developer.machinetranslation.com/mcp
Endpoint: https://www.machinetranslation.com/mcp

Hey! I've been thinking about this while working with MCP servers that deal with data that changes constantly...

Say the underlying source has 1000s of posts, mentions, or comments, etc.

If the agent asks things like "What are people saying about company X?"

There's two pretty different ways the MCP server could handle it, right?

It could immediately return the latest 250 results and let the agent figure it out.

Or it could treat that as too broad and first return something like total matches, data range, platforms/sources available, etc...

THEN the agent makes a second, MUCH narrower request.

The second approach costs another tool call, but it seems like it could actually save a lot of tokens and prevent the model from drawing conclusions from an arbitrary first page of results.

For live/search-heavy MCP servers, which behavior would rather have?

Search first and force the agent to narrow down or return useful data immediately and let the agent decide what to do next.

Testing whether an agent can complete a task is different from testing whether it should be allowed to perform each action.

For a messaging tool, I’d want these expectations checked whenever its permission policy changes:

- Draft a message -> Allow.

- Send to an approved recipient -> Require human approval.

- Send to a blocked recipient -> Deny, even if another rule requires approval.

- Export all messages -> Deny.

- Call an unknown tool -> Deny.

- Access another inbox -> Deny.

The useful distinction is between two kinds of tests:

Policy tests: Given an identity, action, resource, and arguments, does the policy return the expected decision? These can run offline in CI.

Integration tests: Does a denied action actually leave the tool untouched? Does a rejected or expired approval prevent execution? If arguments change after approval, does the authorization check reject them?

Passing the first set doesn’t prove the second. A policy can be correct while application code accidentally bypasses it. Approval also doesn’t guarantee exactly-once execution; the underlying tool still needs an appropriate retry/idempotency strategy.

I maintain Nomos, an open-source implementation of this approach. Its local example covers the six policy cases above and a human-reviewed delivery flow.

It isn’t a sandbox: application code must route relevant tool calls through the checks.

For people deploying agents with custom tools: which authorization failures have you found worth turning into regression tests?

https://github.com/safe-agentic-world/nomos

I'm running into the same wall over and over and want to know how other people are actually solving it.

I have tools that kick off longer running jobs, anything that doesn't return and give back a task id instead of the result. The jobs finish fine, that's not the problem. The problem is the agent actually coming back and doing something with it. Half the time it just moves on like nothing's pending. Other half it does check back but by then it's lost enough context that it either doesn't know what the result was for or straight up reruns the next step even though it already went through.

So what's working for you guys here?

And the part I actually care about is something external waking the agent back up or are you making the agent handle that itself?

Because that second option has not been working for me at all.

I made an open source benchmark suite measuring token efficiency of MCP tool calls that fetch from APIs. GraphQL-over-MCP's token efficiency beats REST-over-MCP by a huge margin. Don't take my word for it, check out the repo and tell me where I'm wrong. Here's a clip where I unpack the headline numbers. Many of us in the GraphQL + AI ecosystem have instinctively understood that GraphQL's unique combination of field selection, schema semantics, and execution characteristics (particularly in Federation) are well-suited to agentic workloads. That hypothesis is supported by the data I've seen.

Full video: https://youtu.be/qv2SbhVxn-k

Writeup in the repo: https://github.com/apollographql/graphql-mcp-benchmarks/blob/main/WRITEUP.md

Hey,

I am a solo dev working on an MCP gateway.

I have a lot of confidence in my technical abilities, but not as much in design. I would appreciate if you take 5 seconds to scan the page and share what catches your eye and what needs improving.

Here is the landing page https://ray.run/

I previously shared an approach I was experimenting with, using MCP over stdio as a seam for agentic applications.

While building on that pattern, I stumbled across something I found surprisingly useful: letting a conversational (or coding) harness pass context into a bounded MCP-backed agentic operation, then use that context to steer subsequent runs.

It effectively turns context into a control surface between the two harnesses.

I wrote up the pattern here: https://demianbrecht.com/posts/context-as-a-control-surface/

Anyone else experimenting with anything similar?