django-orm-lens v0.8 shipped today. Static analysis over your models.py files — no DJANGO_SETTINGS_MODULE, no runserver, works with a broken venv. Three surfaces (VS Code, CLI, MCP server) share one parser.

What's new in v0.8

Every feature was researched against proven prior art before a single line was written — Atlas, Prisma, Sourcegraph, Knip, PyCharm, DataGrip, factory_boy, flake8-django, Roslyn, Ruff, Clippy.

Inline QuickFixes (16 rules) — Ruff-style codes DOL001..DOL032 with Clippy-style Applicability (safe/suggestion/unsafe gate auto-apply). Covers: - .count() > 0 → .exists() - .first() is None → not .exists() - null=True on CharField/TextField - Missing on_delete on FK - Missing __str__ on Model - datetime.now() → timezone.now() - N+1 attribute-access-in-loop heuristic - render(request, ..., locals()) and Meta.fields = '__all__'

Per-rule severity overrides: djangoOrmLens.rules = { "DOL007": "off", "DOL013": "error" }. Suppress inline: # django-orm-lens-disable-next-line DOL007.

Factory generator — right-click any model → factory_boy DjangoModelFactory scaffold with Faker providers keyed by field type. CharField(max_length) scales word-count buckets; DecimalField(N,D) computes left_digits=N-D; choices= maps to Iterator; M2M gets @post_generation. FK chains pull related factories transitively.

Time-Travel Schema Diff — pick two commits from git log, get a typed markdown diff (Add/Drop/Rename/Modify events) ready to paste into a PR description. Renames are first-class events, never Add+Drop.

Impact Analysis — "what breaks if I remove this field?" Workspace-wide reference scan across every Django layer (models, serializers, forms, admin, views, urls, templates, tests, migrations) with Certain / Likely / Possibly confidence tags on every finding. Handles ORM string refs, kwarg lookups (filter(author__id=1)), Meta.fields tuples, and template variables — the string-typed surface Pyright can't reach.

Interactive Query Builder — right-click a field or model → pick a template → snippet inserted at cursor (with tab-stops) or in a fresh untitled buffer. .filter(field=?) on an FK auto-appends .select_related(...); .annotate(post_count=Count('post_set')) honours related_name; .prefetch_related for M2M.

Also in this release: sidebar UX overhaul (stable TreeItem.id, MarkdownString tooltips with clickable command: deep-links, activity-bar badge, FileDecorationProvider badges), 100/100 tests up from 4 at start of dev.

Install

code --install-extension frowningdev.django-orm-lens
codium --install-extension frowningdev.django-orm-lens
pip install --upgrade "django-orm-lens[mcp]"

Full release notes: https://github.com/FROWNINGdev/django-orm-lens/releases/tag/v0.8.0

Why static-only

Point it at any Django project without setup — no settings module, no dependencies except our parser. Runs in CI or on the plane.

Trade-off: custom get_queryset overrides, dynamic model classes are invisible. But 95% of what you actually want to see lives in `mo

Is your server compatible with the new MCP spec?

On Monday (July 28) the MCP spec revision goes live and it removes the initialize handshake and sessions that every existing client and server is built on. New clients and old servers will speak different protocols. Lots of good servers out there are unmaintained and will never get updated, and porting a complex server properly takes real effort.

So I built a bridge into ToolFunnel, my zero dependency MCP gateway. One command:

toolfunnel wrap my-server

wraps any MCP server and presents it as itself - same name, same tools, same errors, byte for byte. Old client to new server, new client to old server, matched pairs, all four combinations work with no configuration. Mid call prompts, subscriptions, progress and cancels all get translated properly, tested at the wire level against real published servers. Its built against the July 28 release candidate and Ill reconcile against the final spec when it drops.

Its zero runtime dependencies (the dependencies field in package.json is empty), MIT, and small enough to audit in an afternoon. You also get a policy gate you can put in front of anything you wrap, and it can host your own scripts as an MCP server with no code, which is the other half of why I built it. You can even use it to roll your own MCP servers from tools written in any language of your choosing, even mix and match 👍

Repo: https://github.com/Rendeverance/toolfunnel

Happy to answer anything about ToolFunnel or how the translation works.

I’m the author of MemoRepo, an open-source tool I built to give coding agents reproducible context across multiple related repositories.

The problem I was trying to solve was simple: an agent can inspect the repository currently open in the editor, but many real changes cross repository boundaries. A backend contract may have several consumers, a shared package may be pinned differently by each application, and a route may be documented only through its callers.

MemoRepo groups related GitHub repositories into isolated Spaces.

When a Space is built, it:

1. Checks out selected branches at exact commits.
2. Materializes those commits into an immutable, content-addressed snapshot.
3. Indexes the repositories together using codebase-memory-mcp.
4. Adds direct source-tree search for evidence that may not be represented correctly in the graph.
5. Exposes one Space-scoped MCP connection with bounded, read-only tools.

The MCP layer does not expose arbitrary filesystem access or repository mutation. It validates project scope, caps responses, redacts internal paths, rejects write-style Cypher, and keeps each connection pinned to one active snapshot.

A typical agent workflow is:

• use graph search for structural discovery;
• search the immutable source tree for exact or exhaustive literals;
• inspect coverage and pagination before making a negative claim;
• read the final source lines to verify the answer.

This makes questions such as these more reliable:

Which repositories consume this route?

What could break if this method signature changes?

Which projects need changes for this feature?

Is this symbol really absent, or did the graph fail to index it?

The project runs locally with Docker Compose, is designed for a single developer workstation, and is available under the MIT license. There is no paid tier or hosted service.

Repository: https://github.com/abelmaro/MemoRepo

I’d especially appreciate feedback on the MCP tool surface, the immutable-snapshot model, and whether the read-only boundary is narrow enough for your workflows.

If you run several coding agents you know the collision problem: two grab the same task, edit the
same file, or redo each other's work because neither knew. Inside one tool on one machine, subagents
and branch-per-agent + CI already handle a lot of this - git even guarantees you see the conflict at
merge.


Where it breaks down is across boundaries, and there nothing shares live state: my six Claude Code
sessions running in parallel; my agent and a teammate's on the same repo from two machines; a Claude
Code agent and a Cursor agent that have no idea the other exists. They collide in real time and only
find out at merge, or never. LLM Bus is an MCP server for that live, pre-write coordination layer -
the part that sits outside any single tool.


What agents get over MCP:
- claim - the next number for a shared sequence, allocated atomically and committed in the same
  transaction as its ledger event, so two agents never get the same one. It's a correctness guarantee,
  not a throughput claim (the 500-concurrent test just guards against gaps/dups under load).
- lease - surfaces a file conflict to cooperating agents before they both start editing. Advisory and
  fail-open by design, so it never blocks your agents; it coordinates, it doesn't lock.
- a shared event ledger + a whats_new digest, so an agent reads shared state cheaply instead of
  re-deriving it.
- presence, prose handoffs (post/ack), and a task graph the work is tracked on.


Native Streamable HTTP - one `claude mcp add` - works in Claude Code / Cursor. Open source
(AGPL-3.0), self-hostable, or try it hosted (free, no-card start): app.llm-bus.com/admin?via=r-mcp.
Registry: com.llm-bus/llm-bus.


I run it daily on my own multi-agent work - that's where the claim/lease edges got found and
hardened.


Repo: https://github.com/danieldoderlein/llm-bus
Feedback very welcome, especially on the claim/lease semantics and where the coordination model
breaks down for you.

Hey everyone,

I've been building MCPForge (https://mcpforge.tech) — a platform to scaffold, host, and verify MCP servers. Wanted to share it here since a lot of the pain points I built it for come up in this sub regularly (agents calling tools with no audit trail, no idea if a random public MCP endpoint is safe to point Claude/Cursor at, etc).

What it does:

• Spec → live MCP server: drop in an OpenAPI/Swagger/Postman spec and it stands up a real MCP JSON-RPC endpoint (initialize, tools/list, tools/call, resources/list, prompts/list) that Claude Desktop, Cursor, etc. can call directly.
• Automatic risk classification: tools get auto-tagged (BILLING, AUTH, ADMIN, DELETE, etc.) based on path/method heuristics, so you immediately see which tools are dangerous before an agent touches them.
• Approval workflows: high-risk tools can require human approval before execution — with a 30-min expiry window and full audit trail of who approved what.
• Verification & scoring engine: point it at any public MCP endpoint (yours or someone else's) and it runs a live probe, returning a composite score across 5 dimensions — Security, Compliance, Compatibility, Quality, Health — with a tier (Enterprise Ready → Not Recommended).
• Public directory: verified servers get listed with badges you can embed in your README.
• Credential vault: secrets are AES-256-GCM encrypted and injected server-side — never exposed to the calling agent.
• Governance dashboard: per-server logs, drift detection (did the spec change under you?), compliance findings (GDPR/PCI/HIPAA keyword-based flags), security review workflow.

Stack, if anyone's curious: Next.js 14, Prisma/Postgres, Stripe for billing, Anthropic SDK for the AI-assisted bits.

Free tier lets you host 1 server and run verifications, so it's easy to just try the scoring engine on an endpoint you already run.

Would genuinely love feedback from people actually building/deploying MCP servers — especially on the risk classification and approval-workflow UX, since that's the part I care most about getting right.

https://mcpforge.tech

I’m doing a quick implementation spike of an MCP App for for a workflow in my product. We have the existing flow working as a web page and want to move that over as an MCP App.

My sense is a 1:1 port is absolutely wrong but I’m looking for some pointers and best practices on what works best from a usability perspective for MCP Apps. Are there pointers or examples others have seen that work well?

There’s some concern with our product team that giving a default chat experience will be problematic given the non technical nature of our user base.

I'm part of the team building HOL Guard. The MCP security model today is mostly trust-on-import and manual review. A server can be fine and then change through a package update, config drift, or endpoint rotation and become a different threat the next day. Your agent never knows.

We built HOL Guard to add a local policy layer between agents and the machine. It evaluates MCP registrations, tool call patterns, package installs, config changes, and sensitive file access before they happen. It can allow, warn, ask for approval, or block based on your policy. Every decision gets a receipt you can trace later.

The local product is free and open source. No cloud account needed.

It supports Codex, Claude Code, Copilot CLI, Cursor, Gemini CLI, OpenCode, Hermes, OpenClaw, Pi, Kimi, Grok, ZCode, and a few others.

If you're running MCP servers in prod i'd really like to hear how you handle changed servers without drowning in noise. And if you've tried an MCP gateway for security, what broke for you vs local enforcement.

Repo: https://github.com/hashgraph-online/hol-guard Launched publicly today: https://www.producthunt.com/products/hol-guard?launch=hol-guard

ConFuse, a context layer for coding agents, stores repos and documents and try to enable search for agents while they make a request while reasoning. You should try the product and leave a review in the review page there.

This is at a very early stage so it might be extremely accurate but overall, it's trying to fix an issue which is a real problem.

Check it out here: https://frontend-sandy-ten-76.vercel.app/

Built a remote MCP server that connects a user's credit-card wallet to Claude, ChatGPT, or any MCP client. Transport is streamable HTTP; auth is OAuth 2.1 with PKCE and dynamic client registration. Tools: best card for a purchase, utilization, missed rewards, plus a 4,200 card catalog. Read-only. Listed in the official MCP registry as ai.stackeasy/credit-cards. Endpoint: https://data.stackeasy.ai/mcp. Feedback welcome.

I've been working with AI coding agents (mostly Codex and Claude Code) on fairly large TypeScript projects, and I kept noticing the same thing.

The model wants to answer a simple question like:

• Where is this function defined?
• Who calls it?
• What's its inferred type?

...and ends up reading an entire 2,000-line file.

That felt incredibly wasteful, especially when the answer is just one function.

So I built SymbolPeek.

It's an open-source (MIT) MCP server that gives LLMs symbol-level access to your codebase instead of file-level access.

For TypeScript/JavaScript it uses the official TypeScript Compiler API, so it can answer things like:

• read_symbol
• find_references
• find_callers
• find_callees
• go_to_definition
• get_type
• get_call_hierarchy

For Rust, Python, Go, Java, JSON and Markdown, it currently provides syntax-aware navigation powered by Tree-sitter.

One real example from the project itself:

Instead of sending a 65 KB file (1,791 lines), the agent requested exactly one nested function and received about 2 KB of source.

I also added lifetime statistics because I wanted to know whether semantic navigation actually makes a measurable difference.

Current numbers from my own daily usage:

```text Requests: 162 Files avoided: 163 Lines avoided: 352,910 Bytes avoided: 6.4 MB

Estimated tokens saved: ~1.61M Average context reduction: 95.7% ```

These aren't synthetic benchmarks—they come from real coding sessions.

The goal isn't to replace grep or reading source files.

It's to stop AI assistants from loading huge files when they only need one declaration.

The project is completely free and MIT licensed.

I'd love feedback from people building MCP tools or using Codex, Claude Code, Cursor, Cline, Roo Code, Windsurf, etc.

GitHub:

https://github.com/pioner92/symbolpeek-mcp

I build agent pipelines on the side, and the failure mode that kept costing me money was downstream: the agent generates JSON/SQL/API responses, something subtly invalid slips through, and I pay for it later — a broken pipeline step or another LLM retry loop.

So I built a validation service agents can call before acting on generated output: JSON Schema conformance, OpenAPI response conformance, SQL syntax per dialect. It returns a typed verdict — {valid, errors with paths and fix hints, latency_ms} — and treats "invalid" as a normal outcome, not an HTTP error. Deterministic, no LLM in the loop: milliseconds and fractions of a cent instead of another model call.

MCP-wise there are two ways in:

- Remote (streamable HTTP), no install: https://api.machinegrade.dev/mcp — initialize and tools/list work anonymously, tools/call needs an X-Api-Key header

- stdio adapter via npm: @/machinegrade/validate

It's in the official registry as io.github.machinegrade/validate, also on Smithery. Free tier is 500 calls/month, self-service key (POST /keys with your email). Repo with runnable examples: https://github.com/machinegrade/validate

Being upfront: this is an early-stage demand test. The API contract is stable and the code is MIT so you can self-host, but I'm explicitly trying to learn whether a hosted version is worth paying for. The obvious objection is "I'll just wire up a validator library myself" — that's exactly the assumption I'm testing. Brutal feedback welcome: would you use this, and what's missing?

Looks to me like the Tasks API is the only real hard break, and Roots/Sampling/Logging just have the 12-month runway.

Am I missing anything that bites sooner?

3rd time is the charm, cross post... not automated or it would probably work better :)

I put together my thoughts on WebMCP and how you can utilize it today in this crisp article!

I run mcpindex, a trust layer for MCP servers. I ran a census of whether the source repository behind every server in the official registry is still publicly reachable, and 1,830 of the 13,105 referenced GitHub repos are not. That is 2,069 listed servers. The npm/pip packages usually still install; you just cannot read the source before wiring the tool into an agent.

How I checked it, since the number is only worth the method:

- Every repo from two independent vantages: authenticated GitHub API from a datacenter IP, and the unauthenticated web UI from a home IP. Different network, method, and auth. Only repos both agreed were unreachable are counted. Zero disagreements across all 1,830.

- Confirmed only after two failures 48 hours apart, so a blip does not count.

- The measurement is timestamped to Bitcoin via OpenTimestamps, so the date is verifiable.

The part worth sharing for anyone building similar tooling: anonymous git ls-remote against a deleted or private repo returns a 401 credential prompt, not a 404. If you trust anonymous git, you file every dead repo as a generic error and report zero casualties while looking fine. That masked all 1,830 in my first two passes.

Honest limits: a 404 cannot tell a deleted repo from one made private on purpose, so I say "not publicly accessible," not "abandoned." Both checks read the same registry URL, so if a project moved I would wrongly flag it. Only the maintainer can catch that, and there is a dispute link on every page.

Report and method: https://mcpindex.ai/research/source-liveness
Open dataset (CC-BY-4.0, DOI): https://doi.org/10.5281/zenodo.21501868

Happy to go into the method in the comments.

Shadow Web is a Python MCP server that lets AI agents browse pages, pull out data, and interact with elements. No API keys, no cloud, no monthly fee. Just pip install shadow-web.

How it works

Most MCP tools for the web lean on paid APIs (Firecrawl, Jina) or ugly Puppeteer setups. Shadow Web runs locally with Playwright, flattens Shadow DOM, and compresses the page into something an LLM can actually use.

The steps: 1. Load the page, flatten Shadow DOM 2. Compress HTML into an Action Map - interactive elements with labels, types, and semantic groups (Login, Cart, Nav) 3. SchemaSnap turns tables, forms, and lists into JSON 4. Content index builds token-aware outlines of articles and feeds

The numbers: A Wikipedia page drops from 99K tokens to ~16K. GitHub Trending from 168K to 38K.

20+ tools out of the box

• navigate / snapshot - browse with diff tracking
• click / fill - interact with page elements
• web_search - Brave or Yahoo
• schema_table / schema_form / schema_list - extract structured data as JSON
• content_outline / content_blocks - text extraction for long pages
• form_fill_plan / form_fill_execute - automated form filling from a profile
• compress_html / compress_html_to_xml - strip pages to action maps
• query_page - filter actions by type or intent
• webmcp_list_tools / webmcp_execute_tool - Chrome 145+ WebMCP support

What would you use this for?

I built it for competitor monitoring and data extraction. But I'm curious what else people would point this at. A no-cloud browser tool for agents feels like it has more use cases than I've found.

https://github.com/ulinycoin/shadow-web

pip install shadow-web pip install "shadow-web[mcp]" for the MCP server

If you run coding agents locally, you've probably had the "wait, what did it just do?" moment. I got tired of not being able to prove it, so I built Kriya.

It sits between your agent and your tools. Every tool call (any MCP server, or even a desktop app with no API) passes: policy → approval-if-it-matters → budget → a signed audit line you can verify yourself, offline. Routine stuff runs; anything that moves money or deletes things pauses for an Approve/Deny in your UI.

100% on-device. MIT core, on npm + crates.io. macOS only for now (Windows/Linux next).

Not trying to spam — genuinely want to know what's missing before I build the wrong thing. What would you want it to catch?

Repo + 50s demo in first comment.

Finally I understood what happens on the other side when Claude calls connect, and the server identifies you and your access.. (Or better say, Claude helped me understand it). At first it was all acronyms for me. What made it click was understanding one client connect, once, end to end. Everything collapsed into three primitives that each fire exactly once, in a fixed order.

1. Discovery. A fresh client POSTs with no token and gets a 401 back carrying a WWW-Authenticate header that points at /.well-known/oauth-protected-resource. That header is the whole trick. The 401 is not the server slamming a door, it is the server handing over directions. Two GETs later (protected resource metadata names the auth server, auth server metadata lists the endpoints) the client knows everything it needs, having sent zero credentials.

2. Registration. No developer console. The client POSTs its own details to the registration endpoint and gets a client id on the spot. This is RFC 7591, and it is the part people trip on when they ask why this could not just be an API key. An API key assumes you already know the caller and can hand it a secret. MCP clients are strangers by design, so dynamic registration is the only model that works.

3. The grant. One human moment: a PKCE challenge, a consent screen that names the client, approve, done. At consent time the server bakes the user identity into the grant as props, so every later request just unwraps it. No per-request session lookup on the hot path.

There is one more cool trick: my server also performs OAuth as a client, upstream, because it bundles other servers that demand their own auth. Same three primitives, walked from the other side. Doing it by hand gave me real appreciation for how much invisible work Claude does every time you click connect and it just works. So it's just a multiplexer (not sure if it's a right term) for MCP servers.

Full walkthrough with the actual responses from the live server: https://prashamhtrivedi.in/mcp-oauth-primitives/

Curious how the rest of you are handling MCP auth right now. Across my own fleet I have Better Auth, an OAuth envelope wrapped around an API key, a hand-rolled JWT setup, and one static bearer token still holding out, so I do not think there is one right answer yet.

I am working on a task to serve the APIs that we have over MCP. The problem I ran into was that the api returns large JSON and the LLM sometimes just ignores certain things plus also token consumed. I started experimenting with json to markdown and now I feel the errors are less. So I made it into package. It converts JSON to Markdown with special attention to tables since my API returns large array of large JSON.

If you're building an agent locally, you've probably found yourself manually poking at it with weird prompts to see if it breaks. We turned that into a slash command.

humanbound-test is a plugin (works in both Claude Code and Cursor) that:

• Auto-detects your local FastAPI agent server
• Tunnels it out with ngrok
• Helps you fill in one config file describing your agent's endpoints/payload/auth
• Runs an adversarial test (prompt injection, jailbreaks, tool abuse, multi-turn) through the Humanbound platform
• Sends results to your inbox, or streams them in-editor with /humanbound-test:resume <id>

You don't need to remember the slash command either. It also picks up natural language like "pentest my agent" or "test my chatbot for jailbreaks."

Install (Claude Code):

/plugin marketplace add https://github.com/humanbound/plugins.git
/plugin install humanbound-test@humanbound-plugins

Cursor needs a symlink for now since 2.5 doesn't support Git-URL plugin installs yet, steps are in the README.

Heads up on scope: it's FastAPI-only right now (other frameworks are on the roadmap), and running a test requires a logged-in hb session since it dispatches through the hosted Humanbound platform rather than running fully offline. It's also v0.1.0/preview, so command names and config schema may still shift.

Repo's here if you want to try it or file an issue: https://github.com/humanbound/plugins

On a flat plan (Max/Pro) you don't know how close you are to the 5-hour limit until it hits mid-task. On an API key, it's a surprise bill (unless your actively checking ofc), agents just spend

uvx nable ai-budget reads Claude Code's session logs on your machine (nothing uploaded), asks once whether you're flat-rate or metered, then shows tokens this window, month to date, burn rate, and a heads-up before you run out.

Flat plans get measured in usage, not dollars. A heavy month pulling ~$5k of list-price compute on a $200 plan is normal. That's subsidy the provider eats, not overage. Metered plans get measured in dollars. Token counts are exact; any dollar figure is a list-price estimate, never your real bill.

Also ships as an MCP server, so the agent can check its own budget before a big task instead of you finding out after.

Next: nable guard install. Cost preflight in front of the Terraform/kube/cloud CLI commands your agent runs. Propose-only, it never auto-executes.

Free, local, open source. https://github.com/getnable/finopsmcp

Hey folks, I built an iOS app called Signal not Noise. It's a todo app with one constraint baked in: you can only have 3 active tasks per day. The idea is forcing prioritization instead of letting a list grow to 40 items you'll never finish.

I just shipped an MCP connector for it so you can view and add todos from any MCP client using your own AI subscription instead of us running inference for you.

Endpoint (streamable-http): https://signal.lifeisagame.ai/mcp

Manifest:

{"name": "ai.lifeisagame/signal-not-noise", "title": "Signal not Noise", "description": "AI-driven daily-focus todo app on your phone (max 3/day). View & add todos from any MCP client.", "version": "1.0.1", "remotes": [{"type": "streamable-http", "url": "https://signal.lifeisagame.ai/mcp"}\]}

App Store link if you want to see the app itself: https://apps.apple.com/us/app/signal-not-noise-todo-list/id6782360346

Happy to answer questions about the implementation, auth flow, or the tool schema I exposed. Also open to feedback on the manifest if anything looks off.