r/mcp • • 1h ago

showcase r/place for Agents

3 Upvotes

Hey r/mcp! I built a fun little app where you can connect your agent via MCP to a canvas and paint pixels on it. It was inspired by r/place if anyone here remembers that.

mcp-place.com

Some background: I'm a DevRel at Databricks on the Neon team and I initiaily built this project as an example for a video I made on how to build MCP servers. It was meant to be just a minimal example, but I figured it could be fun to make it something people can actually connect to and make some collaborative art together.

The way it works is you create an account, then have your agent (ChatGPT/Dots, Claude, Grok Bot, Muse, etc) connect to the app via MCP using OAuth. Once connected, the MCP server exposes an `inspect_canvas` tool to see what's currently on the canvas and a `paint_pixels` tool to actually place pixels.

Come paint some pixels! I'm curious to see what you and your agents come up with :)

If you're interested in how I built it, here's the video. I struggled a bit with how to make it since I'm used to tutorials where someone codes step by step and explains every line. But now a lot of code is written with agents, so I tried explaining the high level architecture first and then showing myself prompting an agent with that knowledge. I'm still pretty new to making videos, so any feedback on that format is welcome. Good or bad!


r/mcp • • 1h ago

showcase stdio2http – a single Rust binary that re-exposes a stdio MCP server over Streamable HTTP

3 Upvotes

Most MCP servers ship as stdio binaries. That's fine until the client is in another container and there is no HTTP endpoint to point at.

stdio2http closes that gap and nothing else: it spawns the stdio server as a child process and re-exposes it at /mcp over Streamable HTTP. Session ids, SSE framing and protocol negotiation come from rmcp, so the transport isn't reimplemented.

What matters when deploying rather than demoing:

  • host validation on by default (loopback only), explicit allowlist for off-host use

  • bearer keys, or identity forwarding as advisory _meta

  • TLS, mTLS, or ACME issuance per listener

  • /healthz answers 503 when the child dies, and the proxy exits non-zero instead of silently restarting

Limits are stated up front: upstream-initiated messages (progress, sampling, elicitation, tools/list_changed) don't forward, and one child serves every caller, so it's single-tenant, not a multi-tenant boundary. If your server depends on those, this is the wrong tool.

cargo install stdio2http

Repo with the README and a demo recording: https://github.com/mimi1vx/stdio2http


r/mcp • • 10h ago

server Open-source MCP server for agent memory: see what an agent knew on a given day

9 Upvotes

Like a lot of people, I built my personal open source (MIT) memory infrastructure for AI agents: https://github.com/Filippo-Venturini/ctxvault

I was struggling a lot to understand and monitor what an agent knew on a given day and what the state of the memory was, so I added to my project a UI that runs without external deps. In the gif you can see a view in which you can drag the cursor and see the actual state of the memory and what Claude (or whatever agent attached to the memory) knew in that moment.

To be precise the memory I've built is grounded in theory, so you actually have memory slots (vaults) which can be semantic, procedural or episodic memory, and all of them are folders on your local machine (so no cloud). In a few simple words: you or your agents can use the semantic ones to store documents and do RAG (and I plan to extend it with graphs), the procedural ones to store skills and procedures for your agents, and the episodic ones to record episodes, that can be closed, superseded or refined as the interaction with the agents goes on.

To plug it into any MCP client (Claude Desktop, Cursor, VS Code...) you need uv installed and these lines in claude_desktop_config.json:

{
  "mcpServers": {
    "ctxvault": { "command": "uvx", "args": ["ctxvault", "mcp"] }
  }
}

You can also try it in the live demo (a simulated bakery with agents that use all the types of memory): https://filippo-venturini.github.io/ctxvault/demo.html

If anyone is curious I'll be happy to share details and I would love some feedbacks or ideas :)

Cheers!


r/mcp • • 3h ago

server Logo.dev MCP Server – Enables searching for company logos by brand name and retrieving customizable logo image URLs with options for format, size, theme, and greyscale conversion using the Logo.dev API.

Thumbnail
glama.ai
2 Upvotes

r/mcp • • 3h ago

connector iPayX FX Audit – Forensic FX audit. Detects hidden bank markups in real time. Returns spread bps + audit score 1-10.

Thumbnail
glama.ai
2 Upvotes

r/mcp • • 18m ago

MCP server for a label printer, and now Claude labels things for me

1 Upvotes

My Katasymbol E11 is a pocket Bluetooth label maker that I never used, because typing on its calculator-sized keyboard is just tedious enough. So I wrote an MCP server for it.

It runs on my home server as a remote MCP server, with a token per client, next to a REST API for apps that aren’t agents. There’s a local mode for Claude on the Mac too. The tools are deliberately dull: printer_status, preview_label, print_label, plus a freezer-label pair. Preview returns a PNG of the label at the printer’s real resolution, and the server’s instructions tell the agent to show it and wait for a yes.

Code (Python, MIT): https://github.com/marco308/supvan-e11-mcp
Write-up: https://marcuslab.uk/projects/label-printer/


r/mcp • • 6h ago

showcase Built an open-source STDIO MCP server that feeds agents Tree-sitter AST skeletons instead of full files (-75.5% tokens on 6 Python bugs)

3 Upvotes

Most coding agents burn through context windows over MCP by grepping around and pulling entire files just to check one signature or import.

I built CodeGraphy (`pip install codegraphy-lite`) to fix that on my own projects. It runs locally as a STDIO MCP server for Claude Code, Cursor, and Windsurf, and parses a Tree-sitter dependency graph across 19 languages.

The flowover MCP is simple:

- `list_workspace_topics` gives the agent the module map

- `get_topic_context(include_ast=True)` returns AST skeletons (imports, types, signatures) for 1-hop dependencies

- The agent only reads ~60-line snippets around the target symbol

I benchmarked it on 6 real bugs in httpx, typer, and rich (baseline grep + whole files vs CodeGraphy Lite MCP):

- Baseline: 144,686 tokens total (6/6 pytest passed, 7.7 tool calls avg)

- CodeGraphy Lite MCP: 35,457 tokens total (6/6 pytest passed, 6.7 tool calls avg, ~4x fewer tokens)

Benchmark runner and full breakdown (including two edge cases where static graphs still miss, like `os.environ` flags and the 35-file cap in Lite): https://github.com/Vindettobkb/codegraphy-lite/blob/main/benchmarks/BENCHMARK.md

Live browser playground to test the graph and toggle files between Full, AST, and Off: https://codegraphy.software/#playground

Repo: https://github.com/Vindettobkb/codegraphy-lite

For folks building MCP servers for codebases, are you returning raw file chunks or trying any kind of AST pruning?


r/mcp • • 4h ago

resource I built OunceMCP, a Python framework on FastMCP that keeps tool results inside a token budget (1.0 release candidate, looking for feedback)

Post image
2 Upvotes

I've been building MCP servers and kept running into the same three problems: one tool call dumps 20k tokens of raw JSON into the context, the model retries a write and does it twice, and nothing stops the model from calling a tool it shouldn't. So I built OunceMCP, a framework on top of FastMCP that makes the careful version the default.

What it does:

- Result budgets. Every result fits a token budget you set and still matches its output schema. Lists are trimmed first, the model gets a note saying what was cut, and pagination cursors move so nothing is skipped or repeated.

- Definition budgets in CI. `ouncemcp check server.py` counts every tool definition the way the host receives it and fails the build when one goes over.

- Search-then-call for big catalogs. Once your tool definitions outgrow the startup budget, the server switches to `search_tools` / `describe_tool` / `call_tool` automatically.

- Safe writes. Every tool declares its effect. Writes can be idempotent (a timed-out write finishes in the background, so a retry gets the result instead of writing twice) and can require a person's approval through the client.

- Security that holds when the model is wrong. Identity comes only from the verified token, one policy decides what each caller can list and call, caches are partitioned by tenant, and outbound fetches refuse private and metadata addresses.

- Works on existing servers. `OunceServer.wrap(my_fastmcp_server)` adds the above without touching your tools, and `ouncemcp audit` measures any MCP server, including ones not built with OunceMCP.

I benchmarked two small example servers against plain FastMCP versions with four models (Claude Haiku 5.5, Claude Sonnet 5.5, GPT-5.4 mini, DeepSeek V4.1 Flash), 840 runs in total:

- On the server with large results, OunceMCP used 58–85% fewer tokens per task.

- On the server with writes, every model on the plain version closed a ticket the user hadn't confirmed and deleted one without permission. OunceMCP refused both every time (100% task success vs 68–70%).

- The honest downside: tool definitions are 1.8–2.4x larger, mostly because of output schemas. On small servers with small results, that means more tokens per task, not fewer. It pays off when results are large.

Full results and caveats: https://github.com/subbusainath/ouncemcp/blob/main/benchmarks/results/m3-bench.md

It's a 1.0 release candidate. The API is frozen, the official MCP conformance suite runs in CI, and an external security review is the last step before 1.0.

```bash

pip install ouncemcp

ouncemcp init notes-server

```

- Docs, including a step-by-step book that builds one server over 15 chapters: https://subbusainath.github.io/ouncemcp/

- GitHub: https://github.com/subbusainath/ouncemcp

Python 3.11+, Apache-2.0. I'd really like feedback, especially from people running MCP servers with large catalogs or multiple tenants: what's missing, what's confusing, and where the defaults get in your way.


r/mcp • • 4h ago

question Need feedback on a Self-Hosted MCP gateway that I am Building

2 Upvotes

Hi everyone,

The journey started for me when I was building some MCP tools for myself to get some things done at work. I found it really difficult to manage the authentication and specially the deployment of MCP Servers so I decided to work on a project which acts as a Gateway. What you could theoretically do would be:

  1. You can write your tools as code or use low code mode (with limitations)

  2. You just have to setup this tool on a server and on this you could deploy multiple MCP Servers in different paths.

  3. The tool would then manage the authentication and deployment for you.

I started already working on this tool, but I am now curious if its only me who had this feeling or is it a real thing? Should I continue on this path or do you guys think that something else would be more helpful?

Its supposed to be a self hosted free MCP Gateway solution so feedback would be much appreciated :) Thank you.


r/mcp • • 6h ago

showcase REQL update: faster context retrieval and fewer tokens for coding agents

3 Upvotes

Hey everyone!

I’ve updated REQL, my open-source tool that helps AI coding agents navigate repositories and preserve working context across sessions.

This release focuses on faster context retrieval and lower token usage. I’ve reduced repeated work during retrieval and trimmed redundant information sent to the agent. Performance gains and token savings depend on the repository and workflow, so I’m not claiming a universal percentage.

If you’re new to REQL, it builds a local graph from your code and documentation: functions, classes, dependencies, calls, and other relationships. Agents can query that graph for context relevant to a specific change, including precise source references and related tests. REQL reuses indexed context and supports incremental updates as the repository changes.

What can you use it for?

  • Waste fewer tokens on repeated exploration: retrieve focused source excerpts and relevant relationships, and reuse indexed context and saved work. This helps reduce repeated searches, unnecessary file reads, and redundant information in the agent’s context.

  • Coordinate work across chats and agents: keep tasks, decisions, blockers, and next steps in a shared project workspace. Another chat or agent using that workspace can recover the recorded state and continue from there.

  • Keep complex tasks on track: record prerequisites, constraints, failed approaches, and checkpoints. Preserve what has been completed, what remains unresolved, and why earlier decisions were made across sessions.

  • Understand unfamiliar code: identify entry points, component responsibilities, and relationships between parts of the application, with references back to the source.

  • Plan changes and refactoring: inspect callers, dependencies, and related tests to identify code that may be affected and decide what needs verification.

  • Review cleanup candidates: find potentially unused imports, variables, functions, and classes, then inspect the supporting evidence before removing them.

REQL provides a CLI, Python API, and MCP server, plus installable instructions for coding agents such as Codex and Claude Code.

REQL runs locally, with no account, external graph database, or mandatory LLM calls. The graph and saved work support the agent’s decisions; current source code and tests remain authoritative.

I’d like to hear from others using coding agents: what do you keep having to explain again when you start a new chat? The code structure, previous decisions, what has already been tried, or what still needs doing? Concrete examples would help me decide what to improve next.


r/mcp • • 8h ago

discussion Loading dozens of MCP tools burns system prompt context before your agent writes code

4 Upvotes

When an MCP server exposes 30 or 40 individual tools, every tool definition gets serialized into the system prompt. Each schema adds names, parameter types, and descriptions to every turn, eating thousands of tokens before the agent reads the first line of code. It also increases tool selection confusion when similar tools compete in the same prompt.

In hosts like Claude Code and other agent runners that support tool discovery, tools can stay deferred until the agent explicitly searches for them. If a server configuration forces tools to load upfront or disables tool search, all tool schemas are dumped into active context on turn 1.

Setting alwaysLoad to false in the server configuration keeps large tool bundles deferred. You can also control deferral behavior globally with ENABLE_TOOL_SEARCH.

Here is an example configuration for a tool-heavy server:

{
  "mcpServers": {
    "database-tools": {
      "command": "npx",
      "args": ["-y", "@example/mcp-server"],
      "alwaysLoad": false
    }
  }
}

When you need specific tools available immediately on every turn (like file search or terminal execution), mark only those tools to load upfront instead of exposing the entire server upfront.

For agents without dynamic tool search, grouping granular actions into a single CLI runner or scoped endpoints prevents context explosion much better than registering 40 separate endpoints.

How do you manage tool schema overhead when running multi-server setups?


r/mcp • • 1h ago

showcase A while ago I shared how getting into the Claude directory took me 4–5 months. Update: we now have 3 ChatGPT apps, and the newest one is a game

1 Upvotes

A while ago I posted here about getting our MCP server into the Claude directory. It took me almost 4–5 months.

Quick update: we now have two apps live in ChatGPT and Claude (workopia and workopia intelligence for global labour market data), and this week a third one was approved in ChatGPT. This one is a game.

I've worked in recruitment for years and I still guess salaries wrong, so I turned it into a game. You see two jobs in two countries and guess which one pays more. The salaries come from 8M+ real job ads, converted to annual USD.

It's built the same way as our other apps: an MCP server, with the game card rendered as a widget inside the chat. Say "play the salary game" and it starts. The video shows one round.

Play in ChatGPT: https://chatgpt.com/plugins/plugin_asdk_app_6aeeb441007881918a7f7331c3e8437b

Also available on Reddit and Discord: Link in the comments.

Happy to answer questions about getting a game approved, or anything else. Which pair surprised you most?


r/mcp • • 1h ago

showcase I built an MCP server so I can stop copy-pasting between my AI agents

1 Upvotes

I use several AI tools on the same projects, and I kept becoming the messenger: copy this finding over, relay that question back, explain what we already decided.

So I built Under Articles. It gives connected agents a shared space to exchange messages, hand off work, and keep a record of decisions.

For example: one agent asks another to review its changes, gets feedback directly, and leaves the outcome where the next session can find it.

It’s early, and I’m the developer. I’d like feedback from people already juggling multiple agents.

To try it, paste this into your AI:

“Read https://underarticles.com/start and help me sign on.”

Some clients need a one-time MCP setup.

What do you find yourself copying between agents most often?


r/mcp • • 9h ago

resource I tried a bunch of free video editors with MCP. These are the ones that stood out

4 Upvotes

I've been doing video editing for the past 2.5 years, and I currently handle 3 freelance clients. The biggest bottleneck is usually getting from a folder of footage to a usable rough cut. Before I can focus on pacing or the creative decisions, I have to sort takes, remove pauses and build the basic sequence.

Lately, I’ve been trying AI video editors, especially ones that connect through MCP, to speed up that first pass. I tried almost all free options, but these were the best free options I found:

  1. invideo Editor

invideo Editor is a free browser-based editor with an MCP connection for Claude and ChatGPT. You can use an external assistant to review footage, compare takes, remove false starts, repeated lines and pauses, and assemble the first cut directly on an editable multi-track timeline. For longer interviews or podcasts, it can also sync multiple cameras, build shorter versions on separate timelines and reframe them for Shorts.

Beyond the rough cut, you can use claude or chatgpt to create keyframe-based text or graphic animations, place and retime existing sound effects, adjust their balance, and make color changes. All of those timeline edits remain manually editable.

2. ChatCut

ChatCut takes a desktop-first approach. Its MCP connection lets an external agent import footage, edit the timeline, transcribe dialogue and add captions while leaving the project open for manual changes. The free plan includes the core editor, transcription and standard project work. Hosted generation uses credits, and free cloud exports have a cumulative 60-minute quota. Local exports do not count toward that limit.

3. FableCut

FableCut is the open-source option here. It is MIT licensed and includes its own MCP server, which can work directly on a multitrack timeline, remove silences, transcribe footage, create captions and export the edit. Every change remains visible and editable in the browser interface. The tradeoff is setup: it runs locally and requires Node 18 or newer plus a Chromium-based browser.

For me, the useful part is not just being able to prompt an editor. It is getting a rough cut on a real timeline, then taking over for the pacing, performance choices and finishing work. Have you used any of these with client footage?


r/mcp • • 2h ago

resource A Permission Review Cycle for AI Agents that Someone Will Actually Run

1 Upvotes

Disclosure: I'm posting on behalf of MCP Manager by Usercentrics.

Hi yall, May have seen me in this sub or others. I enjoy posting helpful resources for the love of the game.

Most agent permissions reviews stall because they are scoped as "review everything." Here's a version sized for a team requiring about an hour a month.

1. Generate the inventory.

One row per grant: The agent, what it can reach (API scope, MCP server, or tool), the credential behind it, and the date it was added. Pull it from the grants actually live, like your IdP, secrets manager, and gateway config. A hand-kept spreadsheet is stale by the second cycle. If your agents reach tools through and MCP gateway, the servers and tools each team can use are already listed in one place.

2. Put one owner on every row.

A person, since a team alias can't answer "what is this for?" Ownerless rows get looked at first.

3. Triage before you review.

You won't get through every row, so sort by risk: Write, delete, send, or spend ahead of read-only, and production ahead of staging. MCP annotations like destructiveHint help with sorting, but the spec threats them as untrusted hints (https://modelcontextprotocol.io/specification/2025-11-25/server/tools), so confirm what the tool really does.

Review the top half each cycle.

4. Compare granted with needed.

For each row in the slice, check the workflow it supports and when it was last used. Unused and unneeded aren't the same thing for quarterly or incident-only jobs, so the owner males the call.

5. Expire by default.

New grants get an expiry the owner picks at grant time, shorter for riskier access. Renewal means the owner confirms it's still needed, which shrinks the next cycle.

6. Keep a decision log.

Every reviewed row gets a decision (keep, narrow, or remove), who decided, the date, a one-line reason, and the next review or expiry date. That's what an auditor asks for, and unchanged recent "keep" rows can be skipped next time.

If you need to justify the time, OWASP lists excessive permissions as a root cause of Excessive Agency in LLM apps (https://genai.owasp.org/llmrisk/llm062025-excessive-agency/).

What's the smallest version of this that has held up for yall? Especially curious how handling grants whose owner has left.


r/mcp • • 7h ago

question has anyone tried dynamic tool discovery instead of loading every MCP schema upfront?

2 Upvotes

lately while messing around with tool using agents i noticed how much of the context window gets eaten up before the agent even does anything. once you hook up 4 or 5 mcp servers, you end up dumping thousands of tokens of tool descriptions and json schemas into every single turn for tools the agent barely ever touches. it gets super waste-ful fast, especially on smaller context windows or longer multi step runs where the model starts losing track of the actual prompt.

because of that i've been testing setups where the agent just searches for what it needs at runtime and only pulls the full schema when it's actually ready to call that specific tool. i'm currently working with monid and that's how we set up its cli and mcp integration, basically giving the agent a searchable catalog of endpoints so all those heavy definitions aren't sitting in context from the start.

m ignoring my own bias though, i'm really curious how other people here are handling this on the engineering side. if you've tried loading schemas on demand, did it actually save enough tokens and improve tool selection for you, or did the extra search step just add annoying latency?


r/mcp • • 11h ago

showcase I got tired of untangling Discord roles and permissions, so I built an MCP server that lets Claude do it with me

4 Upvotes

Disclosure: I'm the developer of discord-mcp, an open-source MCP server (MIT).

I've spent a lot of time running Discord servers, and roles were always the pain:

  • keeping channels consistent with each other

  • knowing exactly who can see what

  • untangling nested roles and permission overwrites

So earlier this year I started building an MCP server that lets an AI assistant help me with that. It grew step by step, and I think it's now far enough along to show you.

It's not a bot that runs 24/7. You start it when you need help with a task (audit who can see what, restructure channels and roles, clean up after a raid, recap a busy channel), and it works through your own bot, with only the permissions you gave it.

It's also built to stay cheap on tokens: you load only the tool categories you need (25 tools, about 10k tokens, for a chat assistant), there's a read-only mode, and mass actions run as a dry run first.

Works with Claude, Codex, Cursor, VS Code and other MCP clients.

If you like it, a star on GitHub helps a lot, and bug reports from testers are very welcome.

What would you want an assistant to handle on your server?

Not affiliated with Discord.


r/mcp • • 4h ago

showcase Built an MCP tool for reviewing AI video takes before retrying — looking for a real workflow test

1 Upvotes

We’re building VOOPA Render Check after repeatedly rerendering shots that missed a brief. It exposes a hosted MCP preview for reviewing an existing image or video, then structuring the decision to keep, edit, retry or investigate further.

The limitation: the calling agent or reviewer must inspect the returned visual evidence. It is not an autonomous guarantee that a take is correct, and we have not established that it saves money. The preview is free and rate-limited.

We tested a public Higgsfield image against its prompt: the tool retrieved the image and returned “review” after the agent noted that the reference and prior attempts were missing. That was our own test, not an external pilot.

We’d like one person who already generates video with an MCP-capable agent to try a short clip and its brief in their normal workflow. Did the evidence help you decide what to do next, or did it just add a step? Honest criticism welcome.

Repository and setup: https://github.com/Voopa-Corp/render-check

Disclosure: I’m associated with VOOPA, which builds Render Check.


r/mcp • • 4h ago

question I made our MCP server return parquet links instead of rows. Is that how you’d handle big datasets?

1 Upvotes

Disclosure first: Im one of the founders of Aperiodic (crypto and stock-perp market data), so Im biased here at least in what usecase we are serving,.

The problem we hit pretty quickly: one month of 5-minute flow data for a single symbol is 8k+ rows by 35+ columns. As JSON that’s roughly 3.2 million tokens, and no model context wants that anywhere near it (we measured it on our free preview file).

so the tools only ever return small JSONs. get_data gives back a ‘handle’ instead of the data: signed parquet URLs (valid for an hour), the schema, the row count, min/max/nulls per column read from the parquet footers, five sample rows and a polars snippet to load it. That whole handle is about ~1700 tokens. The agent’s code downloads the file, and the model itself never sees the rows.

For clients that can’t run code (or can’t download from a signed URL) there’s a summarize tool that does the work on our side: stats, a correlation matrix, or a series resampled down to at most 500 points. search and fetch are in there too, mostly because ChatGPT’s connectors and deep research expect that shape.

Its not perfect. Glamas tool-definition check gave it 3.6/5, and 3/5 on naming, because we mixed verb_noun (get_data, find_symbols) with bare verbs (fetch, summarize). Fair enough, we’ll probably fix it.

What I still dont have a good answer for is clients whose sandbox can’t fetch an external url at all. Falling back to server-side summaries works, but it caps what the model can actually do with the data. Has anyone found something better?

(The preview needs no key, happy to drop the link in a comment if anyone wants to poke at it.)


r/mcp • • 5h ago

showcase ast-bro v4.4.0 adds elixir and gets go doc comments right

Thumbnail
youtu.be
1 Upvotes

i make ast-bro, a rust cli and mcp server that gives coding agents a structural view of a codebase, signatures with line ranges instead of whole files, plus callers, callees and impact.

the mcp side got most of the attention in this release. every property of all 19 tools has a description now, so an agent reading tools/list knows what each argument does, and the build fails if a new one ships without one. the cli and the mcp tools also agree on what the no-fields flag hides now, so the same call gives the same answer on both.

the other changes are elixir support for map, digest, show and implements, go doc comments that match go's own parser on the 143,636 declarations i checked, and show finding dotted names like a c# namespace or a sql table.

the call graph doesn't cover elixir yet. there are prebuilt binaries for macos arm64 and windows x64, and you can install it with homebrew, npm, pypi or cargo. the repo link is in the comments.


r/mcp • • 11h ago

showcase mcp-openrussian: a local, read-only MCP server that grounds LLMs in a real Russian dictionary

3 Upvotes

LLMs are pretty decent Russian tutors until they invent stress marks, use wrong cases after the verbs, or mix up aspect pairs. I wanted them to check a real dictionary instead, so I built an MCP server over the OpenRussian dataset.

Tools:

  • analyze_text: checks every Russian word in a text and returns lemmas, grammatical readings and unknown words

  • lookup_entries: takes any inflected form and finds the lemma and its grammatical forms

  • search_entries: searches by English or German meaning, or by Russian spelling

  • get_entry: returns the full entry with inflection tables, translations, government, aspect partners and examples

  • browse_entries: filters by frequency rank, CEFR level and part of speech

  • find_examples: finds Tatoeba sentences for a word or a specific form

Details:

  • Python 3.12+ and SQLite. Read-only, and no network calls during lookups

  • Works with any MCP client. MIT licence. Data is CC BY-SA 4.0 (OpenRussian) and CC BY 2.0 FR (Tatoeba).

If you’re learning Russian and want to try it, please let me know how it goes!

PRs are welcome: new tools, tests, docs, client configs.
A similar server for other languages would be a fun fork as well!

👉 link to mcp-openrussian


r/mcp • • 22h ago

showcase From phone photos to a playable Counter-Strike 2 town: my MCP server let Claude build the whole thing

Thumbnail
gallery
20 Upvotes

I made this, it's free and open source (MIT). This is the first full map made with it.

What it is. An MCP server for Counter-Strike 2 maps. The agent doesn't click around in Hammer. It writes the map files directly, runs Valve's own compiler, loads the map in CS2, takes screenshots, plays it with real input (walking routes, key presses, bot matches) and fixes what it sees. There are 49 tools, but almost everything that goes into a map is one tool, map_edit, with batches of operations.

Why. I wanted big maps without spending years on them, even if the quality is lower than hand-made. Also fun mechanics for friends (cars, turrets, custom weapons) and maybe small story maps made in a couple of days.

The map. A small post-Soviet town. At first the agent only had map screenshots, later my own photos of real streets. It also found road maps and elevation data online by itself. The result is about 24,500 map nodes in 41 packages made by 38 generators: terrain, roads, panel and brick houses with flats inside, garages, fences, trees, a bus and a car you can drive. My part was mostly pointing at problems in words.

The thing that sped up feedback the most: player marks. I walk around the map in CS2, press F8 at a problem and type a note in chat. The agent gets my position, view direction, a screenshot and the note. Before that I had to explain in words where the problem was.

What I learned building an MCP server for a game

  • Invest in speed early. If one change takes 15 minutes to show up in the game, the model's limits and your time go into waiting, not into the map. Version 1.4 was only about that (measured on the town map, 24,500 nodes, 270 MB):

StepBefore1.4
Change → frame in the game12–15 min~1.5 min
Rebuild with nothing changed—18 s
Change in one late package—42 s
Cut, build and screenshot one zone—50 s
Scene checks on the whole town220 s90 s
CS2 window jumping in front during testsevery testnever
  • Don't fight the user for the screen. At first CS2 had to be in front of everything and it grabbed the mouse, so Claude and I kept getting in each other's way. Now the game renders and takes console commands in the background, and a small local panel shows what the tools are doing.

  • Model: Claude Opus 5.5 with high reasoning did the maps. Codex helped early with Blender models, but on maps it did badly (that was an early version of the server).

What's still bad

  • Roads and complex junctions. Most of the town comes from generators, and the agent has to rewrite them again and again without breaking what already worked. A good result is possible, it just takes a lot of time.

  • It's one-way with Hammer. You can open the map in Hammer and finish it by hand, but when a generator runs again, your edits to the parts it made are overwritten. Objects you add yourself stay.

  • Windows only, and the quick house and street builders have one look so far.

GitHub: https://github.com/Rmgs123/cs2-map-mcp

Workshop map: https://steamcommunity.com/sharedfiles/filedetails/?id=3838852950

If you've built an MCP server for a heavy desktop app, how did you deal with slow feedback loops?


r/mcp • • 5h ago

[Showcase] MCP server for an on-premise dialer: calls, texts and CRM on by default with limits you set, separate switch for campaigns

1 Upvotes

Disclosure: This is from Voicent, the company that makes the dialer, and the post was drafted with AI help. The MCP server is free and MIT licensed, but production use needs a paid Voicent Gateway license, explained below.

The server lets an MCP client operate a Voicent Gateway (10.10.3 or later) running on your own machine. There are 20 tools, and 14 are on by default:

- Always on: `call_status`, `campaign_status`, `import_status`
- On unless `VOICENT_ALLOW_CALLS=0`: `call_text`, `call_audio`, `call_ivr`, `send_sms`, `call_remove`
- On unless `VOICENT_ALLOW_CRM=0`: `crm_get_field`, `crm_add_or_update`, `crm_set_field`, `crm_add_note`, `crm_schedule_callback`, `crm_notify_agent`
- Off unless `VOICENT_ALLOW_CAMPAIGNS=1`: `campaign_import_list`, `campaign_upload_audio`, `campaign_export`, `campaign_run_autodialer`, `campaign_run_text`, `campaign_run_email`

How the limits work:

- It's on out of the box: by default the agent can call or text any number and read and change CRM records, so set your limits before connecting. Tools that are off aren't registered.
- `VOICENT_ALLOWED_NUMBERS` limits single calls and texts to a list of numbers.
- CRM reads send customer records to your AI provider. Only known fields can be changed. The agent can set do-not-call or do-not-email, but through the CRM tools, only a person can clear do-not-call or do-not-email.
- The number list doesn't apply to campaigns. A campaign contacts everyone on its list, which is why campaigns stay off until you turn them on.
- List imports aren't limited like the CRM tools. With campaigns on, a list import can update any column of matching contacts, including clearing do-not-call, from files in `VOICENT_FILE_ROOT`. Only put files there that you'd import yourself.
- Requests come from a fixed set of fields, so the server never sends the gateway's fields for running programs or database queries, or its do-not-call bypass.
- File tools stay inside `VOICENT_FILE_ROOT` and refuse to run without it.

What's missing or broken:

- Email campaigns are only tested in simulation.
- `call_ivr` can't check that an app is outbound.
- An IVR app with no answering machine message can occasionally end as failed when it reaches voicemail. Add the message to the app in IVR Studio.
- Phone and email lookups can match the wrong CRM record when there are duplicates.
- No predictive campaigns, scheduled campaigns, CRM search, listing or deletion, and no uploading files to a remote gateway.
- No confirmation step or audit log.
- File tools only work when the server runs on the gateway machine.

It isn't an AI voice agent: the AI operates the dialer and doesn't hold conversations on the call. Set the gateway's Remote Connect Password and keep port 8155 off the internet, because these limits only cover what the server sends. Consent and calling laws are still on you.

Cost: the server is free. For production use, the gateway needs a Workflow license plus Enterprise Edition, priced by quote, as a one-time license. Annual support is strongly recommended. It costs 30% of the purchase price per year, with a $99/month minimum. Without support, we won't be able to help you if the software fails to work for any reason.

We'd like feedback on three things: is having calls and CRM on by default the right choice, is a separate campaign switch enough, and would you want a confirmation step before a campaign starts?

Repo: https://github.com/voicentmcp/voicent-mcp


r/mcp • • 9h ago

Web Design Is Turning Into WebMCP

Thumbnail
blog.galratner.com
2 Upvotes

r/mcp • • 7h ago

showcase I built an open-source MCP gateway for enterprises: k8s deployment and role-based access and guardrails on every tool call

1 Upvotes

I've spent 25 years building enterprise messaging and distributed systems, and wanted to bring the same discipline to AI agents. So I built Enterprise MCP Proxy, an open-source gateway that sits between MCP clients and your MCP servers.

What it does:

  • One endpoint for all your MCP servers, discovered automatically on Kubernetes, with tools namespaced per server

  • OAuth 2.1 login through your identity provider (Okta, Entra ID…), and role-based access to every tool, prompt and resource

  • Guardrails on every call and result: JSON-Schema rules, business-logic checks, and plain-English rules judged by an LLM, all failing closed

  • Audit trail: every call, block and alert is an event, traceable end to end with one tool-call ID

  • Rate limiting, live configuration (no restart), and admin tools that are themselves MCP tools, so an authorized agent can operate the gateway

  • Written in Go, MIT licensed, with a full demo app (a gardening store with 5 MCP servers, users and roles) you can deploy locally in a few minutes.

Repo: https://github.com/pellucon/enterprise-go-mcp-proxy

Site: https://pellucon.github.io/enterprise-go-mcp-proxy/

I'd love feedback, especially from anyone running MCP servers inside a company: what's missing for you to put something like this in front of them?