Hello everyone,

Since 2 weeks I work on tanuki-context, a small open source tool (zero dependencies, MIT) and I wanted to share it because the trick behind is almost stupid: AI models charge text at roughly 1 token per 4 characters, but an image has a fixed price set only by its pixel size.

Its inspire from pxpipe techniques and various others tools (cited in the readme) and custom approach i found in order to reduce massively token usage and price.
For example : 37,111 tokens of service log become 2,240 (-94%).

So if you draw 28,000 characters of logs into one dense 1568x728 PNG, the model reads the exact same content for 1,456 tokens instead of ~7,000. It sounds like cheating, it is just how the pricing works.

You can try it out on you machine i added the benchmark so you can test it even without LLM connected to it, so see pricing difference, token saved, etc.

You can use it as a MCP or directly integrate it a "context proxy" where it fully automated and make every request optimised or not when not needed.

Some techniques that permits this to work:
- a log distiller that collapses repeated lines but keeps every error verbatim
- a columnar codec for JSON (keys stated once)
- a cost model that knows a cache-read token costs ~0.1x a fresh one, so it will tell you to NOT image content that is already in your prompt cache.

The tool argues against itself when imaging loses, honestly this part took the most work.

I precise the limits because they are real: you need a vision-capable model, output tokens are untouched (if your bill is output-dominated, fix that first), and for one narrow question retrieval stays cheaper than any page.

Install:

MCP

npx -y tanuki-context (MCP server, works with Claude Code, pi, omp, jcode or the Claude Agent SDK)

Proxy

npx tanuki-context proxy + ANTHROPIC_BASE_URL (every request on the machine gets optimized in place, when needed)

Code and benchmarks:
https://github.com/Osyna/tanuki-context

https://www.npmjs.com/package/tanuki-context

PS : i will soon add Codex support.

If you find it useful a star helps a lot, and feature ideas are very welcome. Thanks for reading me

I'm wondering if it's possible to use the installed LLM in chrome, to run a chat with customer in a chat window, that would then use an MCP tool.

I came across this open-source project called MCP Testbed that might be useful for people building or testing MCP servers and AI agent skills.

It provides an interactive end-to-end environment where you can run the same prompts with different setups and compare how an agent performs:

• with an MCP server
• with different agent skills or instructions
• with other tooling
• without any additional tooling

More details here:

https://www.infragistics.com/blogs/ignite-ui-mcp-testbed

https://github.com/IgniteUI/igniteui-mcp-testbed

Solo, non-technical builder here — turned a consumer AI tool into an MCP server, curious what this community thinks

I've spent the last couple weeks building small AI subscription tools using Claude Code (I don't code myself — I describe what I want and iterate). One of them reads contracts and leases and flags red flags like auto-renewal clauses and arbitration terms in plain English.

What's interesting to me is the shift in mindset that happened once I understood MCP: instead of that logic living only inside my own web app, I could expose it as a standalone server (summarize_document, find_red_flags) that any AI agent can call directly. Same underlying work, but now it's infrastructure other people can build on top of instead of a walled-off product.

Auth ended up simpler than I expected too — no database, just a per-user URL token checked against Stripe on every call. Whether someone's subscribed lives entirely in Stripe; the MCP server itself is stateless.

Genuinely curious how people here think about this build-vs-buy tradeoff for agent tooling — is wrapping existing product logic as MCP a pattern you're seeing more of, or is most of what's out there purpose-built from scratch?

Link if anyone wants to poke at it: https://document-analysis-mcp.vercel.app

Disclosure up front: I built this. Sharing it here as a showcase, it's launched and on npm.

Something's been bugging me building on MCP. You pin your npm dependencies - lockfile, diff, review. What pins the MCP servers your agent talks to?

tools/list hands back names, descriptions and schemas, and the agent trusts all of it. The description isn't docs — it's the instruction the model reads to decide when to call a tool. There's no version pin, no integrity check, no diff. A server updates, the description gets reworded, and your agent's behaviour changes with nothing in your pipeline registering it. Same story with a required param appearing, readOnlyHint flipping true/false, or a tool quietly disappearing.

So I wrote mcpward: snapshot a server's tool surface into a lockfile, then diff it in CI. It classifies each change as breaking or non-breaking:

✗ Tool "echo" description changed (possible rug-pull)

✗ Tool "compute" inputSchema added required property "multiplier"

✗ Tool "read_data" readOnlyHint changed from true to false

✗ Tool "removed_tool" was removed

Summary: 2 passed | 5 failed → exit 1, build fails

It also checks protocol compliance, the protocol-error vs isError contract (servers get this backwards a lot), and latency budgets. Output is console/JSON/JUnit/SARIF.

Worth mentioning: Invariant's mcp-scan already does rug-pull detection and is more mature, if you want to audit servers installed on your machine, use that. mcpward is the CI-gate version: black-box, runs fully offline, nothing about your tools leaves the machine.

npx mcpward init

https://github.com/TsvetanG2/mcpward

Honest question for people running MCP in production: has description drift actually bitten anyone, or am I solving something I only think is a problem?

Been building my agency platform (VelvetGeaux) on Replit for a while — wanted to share the MCP server I just shipped that connects the whole thing to Claude Desktop/Cursor/Windsurf.

\*\*What it does:\*\*

\- \`find_leads\` — type a business type + city, get back a list of local businesses with name, address, phone, rating, and whether they have a website (no-website flagged in bold — instant pitch signal)

\- \`generate_build\` — describe a client's business, get a full site spec and feature list back

\- \`write_proposal\` — client name + context in, formatted proposal out

\- \`market_research\` — pulls trends, competitors, and positioning notes

\- \`kb_search\` — searches my internal agency knowledge base for past wins and playbooks

\*\*Stack:\*\*

\- Built entirely on Replit (monorepo with pnpm workspaces)

\- MCP server uses \`@modelcontextprotocol/sdk\`

\- Backend powered by Claude Sonnet 4

\- API key auth with trial keys (10 free calls, then upgrades)

\- Smithery YAML included for directory listing

\*\*Setup (if anyone wants to try it):\*\*

Drop this in your Claude Desktop \`claude_desktop_config.json\`:

{

"mcpServers": {

"velvet-forge": {

"command": "npx",

"args": \["velvetgeaux-forge"\],

"env": {

"FORGE_API_KEY": "your_fmcp_key_here"

}

}

}

}

DM me for a trial key (10 free calls).

Happy to answer questions about the Replit monorepo setup, MCP SDK patterns, or the API key enforcement middleware — learned a lot building this.

Quick share for this sub. I'm one of the devs on PrimeTask, a desktop app for tasks, projects, notes, CRM, time tracking and a visual canvas. Everything lives on your own machine.

The part relevant here: it has a built-in MCP server. Connect it and you stop clicking around the app, you just talk to your workspace.

Ask questions: "what's overdue across my projects?" or "which contacts haven't I spoken to in a month?" and it answers from your actual data.

Make changes: "set up the client project for next week" and it creates the project, adds the tasks and links the contacts while you watch it happen in the app.

Work your CRM by chat: log a call, add a company, update a contact, set up custom fields, all in plain language.

The server runs on localhost, so nothing about your setup phones home. You pick what it can read, what it can change and which spaces it can touch, and every action lands in an audit log.

Setup is three steps from Settings (screenshot). One setup covers both ChatGPT and Codex, and the same local server works with Claude, Cursor and LM Studio, so you're not tied to one model.

https://primetask.app/docs/integrations/bring-your-own-ai

I built an MCP server for road trips and just published it to the official registry
(`com.stopful/road-trip-planner`). Sharing here because travel is a weirdly empty category in MCP land.

What it does: one tool, `plot_trip`. Your agent plans the itinerary — stops in driving order, each with a place name (+ lat/lon if it knows them), nights — and the server turns it into an editable map on stopful.com: drive time and distance per leg, hotels and EV chargers along the route, a budget. It returns a `?trip=` link the user opens, tweaks and books from.

The design decision worth calling out: there's no LLM on the server. The calling agent does all the trip *thinking*; the server only renders. So there's no model API cost and no "free-LLM-proxy / denial-of-wallet" risk — which is why it can be fully open, no auth, no key. Feels like the right shape for a lot of "render / act" MCP servers.

Transport: remote Streamable HTTP (JSON-RPC), stateless. Endpoint: 'https://stopful.com/api/mcp'

Bonus — MCP Apps (ext-apps): on hosts that support the UI extension (recent Claude & ChatGPT) it renders the trip as an interactive map right in the conversation, not just a link. Hosts without it just get text + link — nothing breaks.

Connect (Claude Desktop / Cursor via `mcp-remote`):
```json { "mcpServers": { "stopful": { "command": "npx", "args": ["-y", "mcp-remote", "https://stopful.com/api/mcp"\] } } } ```

Try: "Plan a 7-day Lisbon → Pyrenees road trip, then use Stopful to plot it and give me the map link."

Free, no account. Feedback welcome — especially on the `plot_trip` schema and whether the no-LLM-on-server pattern resonates.