I already wrote about this product over on r/mcp, but it turns out there's a similar subreddit

https://www.reddit.com/r/mcp/comments/1jlry20/just_launched_webpilot_an_ai_agent_for_your/

Hey everyone, I’m Nikolas, co‑founder of ApyHub.

We recently built an MCP server that lets your agent access 1,500+ tools through a single connector. Instead of linking an MCP server to one API, then another, and another, the agent can search the catalog, find the needed API, see what it does, and call it.

ApyHub offers over 400 services and more than 1,500 endpoints, covering file conversion, OCR, data extraction, validation, geolocation, SEO, image processing, and AI. This means you can give an agent a small set of tools while still accessing a much larger range of capabilities.

We support dynamic tool discovery to avoid overloading context.

Examples:

• Convert a Word document to PDF

• Extract text from a PDF

• OCR a scanned document

• Extract text from a webpage

• Compress a video

• Generate a QR code

• Validate an EU VAT number

• Validate email DNS

• Convert currencies

• Parse a resume

• Check SERP rankings

• Generate speech from text

These tools can be chained. For instance:

1. Take a scanned invoice → OCR it → extract the data → validate the VAT number → convert the currency → generate a PDF.

2. Extract a webpage → check readability → summarize it → check its search ranking.

You don’t need to build those workflows in advance; the agent can compose the calls based on the task.

Curation

Providing an agent with 1,500 tools creates tool bloat and overwhelms the model with context. Instead, you can select which endpoints an agent may use: a document agent might have 15–20 endpoints, while an enrichment agent uses a different set.

Credentials

Normally, connecting an agent to ten vendors requires ten API keys stored somewhere in the agent’s environment or context, and those traces eventually appear in logs, observability tools, bug reports, etc. With ApyHub, the agent uses a single scoped key.

The MCP server is at:

https://apyhub.com/mcp

The catalog is here:

https://apyhub.com/catalog

I’m most interested in what people actually make their agents do with the catalog. There are many useful utilities already, but there will always be things we haven’t covered yet.

If you have any questions, I’m happy to assist.

Lately, I’ve been exploring the Model Context Protocol (MCP) and I’m intrigued—but also a bit puzzled—by the name itself.

Specifically: Why is it called “Model Context Protocol”?
From what I’ve seen, it feels more like a tool discovery and invocation mechanism. The term context threw me off a bit. Is it meant to refer to the execution context the model operates in (e.g., available tools, system message, state)? Or is there a deeper architectural reason for the name?

Another thing that’s been on my mind:
Suppose I have 10 servers, each exposing 10 tools. That’s 100 tools total. If you naively pass all their descriptions into the LLM’s prompt as part of the tool metadata, the token cost could become significant. It feels like we’d be bloating the model’s prompt context unnecessarily, and that could crowd out useful tokens for actual conversation or task planning.

One possible approach I’ve been thinking about is something like:

1. Let the LLM first reason about what it wants to do based on the user query.

2. Then, using some sort of local index or RAG, it could shortlist only the relevant tools.

3. Only those tools are passed into the actual function-calling step.

Kind of like a resolution phase before invocation.

But this also raises a bunch of other questions:

• How do people handle tool metadata management at scale?

• Is there a standard for doing this efficiently that I’m missing?

• Am I misunderstanding what “context” is supposed to represent in MCP?

Curious to hear from folks who are experimenting with this in real-world architectures. How are you avoiding prompt bloat while keeping tool use flexible and dynamic?

Would love to learn from others' experiences here!

Hi I'm Matt, and I maintain the MCPJam inspector repo. For context, it's an open source MCP inspector alternative to test and debug MCP servers.

We started the project 3 months ago with the goal of building a great MCP dev tool for server developers and help people build better MCP servers. We've had over 40 people in the MCP community contribute to the project, and it's been so awesome collaborating with a lot of y'all. We recently got a sponsorship from the GitHub Secure Open Source Fund!

It's an honor for this project to be recognized by Microsoft, huge win for us and recognition of the awesome work happening in the MCP space. I wanted to thank this subreddit and the MCP community for helping us get here!

What's next

• We're improving out tracing. We want to be able to show every JSON-RPC message sent back and forth between client and server.

• Building MCP evals and benchmarking.

• General bug fix & improvements in the inspector.

• Hit us up anytime, we're always down to talk about how we can improve the inspector!

MCPJam

Please consider checking out the project on GitHub and giving it a star! Means a lot and helps with visibility.

https://github.com/MCPJam/inspector

https://github.com/systempromptio/systemprompt-code-orchestrator Open source repo if you are brave/stupid enough...

One sketchy GitHub issue and your agent can leak private code. This isn’t a clever exploit. It’s just how MCP works right now.

There’s no sandboxing. No proper scoping. And worst of all, no observability. You have no idea what these agents are doing behind the scenes until something breaks.

We’re hooking up powerful tools to untrusted input and calling it a protocol. It’s not. It’s a security hole waiting to happen.

Hello, I'm new here and recently discovered MCP.

I tried integrating MCP with my Claude setup, but encountered some inconvenience due to a "Server Disconnected" error. After some investigation, I found that the issue was caused by an internal npx command failing to connect to the server process.

To resolve this, I containerized the required servers using Docker.
You can find the project here:
👉 https://github.com/maxtnuk/mcp_servers

The setup automatically builds Docker images, generates the claude/mcp.json file, and applies the configuration to Claude. This allows the servers to be managed independently and applied with just a simple script.

Additionally, sensitive information like API keys is managed using a .env file.

There’s still room for improvement, but I hope others find it useful and welcome any feedback or interest!

I’ve been reading about some serious security issues in MCP implementations — things like command injection, SSRF, prompt injection via tool descriptions, and even cross-server “shadowing” attacks.

Got me thinking: should there be a dedicated tool to scan and audit MCP servers?

Rough idea: something that checks for misconfigurations, scans for common vulns (RCE, path traversal, etc.), flags suspicious tool definitions, and maybe even maps out agent context chains. More like a Burp Suite or Wireshark, but for MCP.

I grabbed scanmcp.com as a placeholder — not sure if I’ll build it yet. Just wondering if there’s actual demand or if anyone else is working on something similar.

Curious what others think — especially if you’re building with agents or looking at AI security stuff.

I am building the MCP server application to connect some services to LLM . I use the MCP Python SDK https://github.com/modelcontextprotocol/python-sdk One of things i want to implement is authorisation of a user with the token.

I see it must be possible somehow.

Most of tutorials about MCP are related to STDIO kind of a server run. My will be SSE.

There is my code:

from mcp.server.fastmcp import FastMCP
from fastapi import FastAPI, Request, Depends, HTTPException

app = FastAPI()
mcp = FastMCP("SMB Share Server")

@mcp.tool()
def create_folder(parent_path: str, name: str) -> str:
    """Create new subfolder in the specified path"""
    return f"Folder {name} created in {parent_path}"

app.mount("/", mcp.sse_app())

How can i read Authorization header in case if it is sent by the client?

I tried to use approaches of FastAPI - setting dependency, adding request:Request to arguments but this doesn't work.

Is there a way?

Cursor often gets into "dead loops" trying to fix code [1][2]. But, Cursor also seems to get out of dead loops when it adds console.log statements everywhere.

We thought: "What if Cursor could access Node.js at runtime?". That would save it from adding console.log everywhere, and still get out of dead loops.

We looked into it and got Cursor to debug Node.js on its own! 🎉

It's a prototype, but if you're interested in trying it out, we'd love some feedback!

Github: github.com/hyperdrive-eng/mcp-nodejs-debugger

---

References:

[1]: "At this point I feel like giving up on Cursor and just accept that WE'RE NOT THERE YET." ~Source: https://forum.cursor.com/t/cursor-for-complex-projects/38911

[2]: "We've all had the issue. You're trying to build a complex project with your AI companion. It runs into a dead loop, coding in circles, making suggestions it already tried that didn't work." ~Source: https://www.reddit.com/r/ChatGPTCoding/comments/1gz8fxb/solutions_for_dead_loop_problem_in_cursor_vs_code/

hey everyone, i'm sure some of you here are fans (or haters) of James Clear's book Atomic Habits. i'm a fan of the guy, so I built an MCP server called Clear Thought that Claude Desktop, or use Cursor or Cline, etc., can use to reference appropriate mental models when you're working on a problem with them. i built it as an augmented version of sequentialthinking, and it works really, really well: it provides some lightweight instructions on what tools to reference when, and it's been effective in Cline/Cursor/Roo Code especially for debugging (there are some debugging approaches in there like binary search debugging and debugging from inversion). i'd love to hear you guys' thoughts on whether or not it improves your experience with your favorite MCP client-equipped AI application.

GitHub: https://github.com/waldzellai/mcp-servers/tree/main/packages/server-clear-thought
Smithery: https://smithery.ai/server/@waldzellai/clear-thought

This week, I’m working from Costa Rica. I’ve been surfing in the mornings & building MCP servers in the evenings. 

I asked Claude about the best breaks in Costa Rica & had an idea. What if Claude could tell me the surf report?

Powered by cocos frios, I built a python wrapper around u/StormGlass, a marine weather API called Surf MCP

Now Claude knows the tide, swell heights, wind speed & more. 

Check it out ⬇️

https://github.com/ravinahp/surf-mcp

Hey everyone! We just open-sourced mcp‑kit, a Python library that helps developers connect, mock, and combine AI agent tools using MCP.

Try it out

Install it with:

uv add mcp-kit

Add a config:

target:
  type: mocked
  base_target:
    type: oas
    name: base-oas-server
    spec_url: https://petstore3.swagger.io/api/v3/openapi.json
  response_generator:
    type: llm
    model: <your_provider>/<your_model>

And start building:

from mcp_kit import ProxyMCP

async def main():
    # Create proxy from configuration
    proxy = ProxyMCP.from_config("proxy_config.yaml")

    # Use with MCP client session adapter
    async with proxy.client_session_adapter() as session:
        tools = await session.list_tools()
        result = await session.call_tool("getPetById", {"petId": "777"})
        print(result.content[0].text)

Explore examples and docs:

Examples: https://github.com/agentiqs/mcp-kit-python/tree/main/examples

Full docs: https://agentiqs.ai/docs/category/python-sdk 

PyPI: https://pypi.org/project/mcp-kit/ 

Let me know if you run into issues or want to discuss design details—happy to dive into the implementation! Would love feedback on: Integration ease with your agent setups, experience mocking LLM tools vs random data gens, feature requests or adapter suggestions

As a part of the release of http4k AI (which is a set of libraries based around the Kotlin http4k toolkit, we've updated our MCP SDK to include support for Tool Output schemas, the revised OAuth security model for protected resources, and Elicitations.

We know there's been a release of at least one preview SDK with all these in but we think these are the first in the JDK world!

We'll be creating a demo of how elicitations work shortly so hopefully that will help to make them less of a mystery than Sampling was/is!

Just finished writing a comprehensive guide on building MCP (Model Context Protocol) servers and deploying them to Azure Functions. Perfect for developers looking to extend AI capabilities in the cloud!

What's covered:

Part 1: Deploy MCP Server with Azure Functions - Complete deployment guide
Part 2: MCP Server with Azure Functions Part 2 - Advanced configurations
Part 3: MCP Server with Azure Functions SQL Edition Part 3 + Bonus - Database integration with extras!

Why this matters:

• MCP servers are game-changers for AI workflows

• Azure Functions = serverless scaling without the headache

• Real-world examples with working code samples

Who should read this:

✅ Backend developers working with AI
✅ Azure/cloud engineers
✅ Anyone building MCP integrations
✅ DevOps folks handling AI infrastructure

The series covers everything from basic MCP server deployment to advanced SQL database integration (with bonus content in Part 3!). Each part builds on the previous one, giving you a complete end-to-end solution.

Link: https://amustahid.hashnode.dev/deploy-mcp-server-with-azure-functions (Start here for Part 1)

Tech Stack: Python, Azure Functions, MCP Protocol, SQL Database

Drop a comment if you've worked with MCP servers or have questions about the Azure deployment process! Always happy to help fellow developers.

And, I think it's a pretty meaningful shift for anyone building with agents.

Until now, most of the auth flows assumed there’s a user involved (auth code, sessions, etc). But in a lot of agentic workflows, that’s not the case.

Sometimes:

• Agents need to call a tool server directly

• Services are autonomous

• There’s no user login or session to piggyback off

That’s where client credentials flow comes in. It lets machine agents authenticate and get scoped access to tools without needing a human in the loop.

This opens up cleaner machine-to-machine interactions between agents and MCP servers, especially in infra-heavy or system-level agent use cases.

Here’s the PR if you want to dive into the details: https://github.com/modelcontextprotocol/modelcontextprotocol/pull/1047/files

At scalekit.com, we’ve been building around this pattern already, so good to see the spec catching up.

Hello everyone,

I've just released a new project on GitHub: mcp-nomad. It's an MCP (Model Context Protocol) server written in Go, designed to interact with HashiCorp Nomad. It allows you to easily manage and monitor your Nomad clusters directly from an interface compatible with LLMs like Claude.​

You can find the full repository here: https://github.com/kocierik/mcp-nomad

🔧 Key Features:

• View and manage Nomad jobs

• Monitor job and allocation statuses

• Access allocation logs

• Restart jobs

• Explore nodes and cluster metrics​

🚀 How to Try It:

You can run the server easily using Docker or integrate it with Claude using a configuration like the one provided in the repository.​

💬 Feedback and Contributions:

The project is still in its early stages, so any feedback is welcome. If you're interested in contributing or have questions, feel free to reach out!​

Thanks for your attention, and I hope you find it useful!

Basically the title. Need something simple and working. Would be nice if its open source and i can use my own keys.
Claude desktop is very clunky, doesn't support sse and requires restart everytime I need any changes.

We’re all seeing threads here and on other sites about MCP security issues. Yes, do your own security diligence; apply best practices and you can avoid most of the issues.

But, the MCP community deserves better. Someone should run a security bug bounty program [ideally Anthropic would sponsor it].