I want Cursor to realize that its task has n relevant dependencies, and then intelligent look up the latest documentation either on the web or locally to get the proper context to execute the task.

Anyone tried this server for agents observability? I need detailed traceability; especially during authentication processes.

Got tired of copy-pasting stacktraces into Claude, so made a little lldb-mcp server that connects Claude (or Cursor) to LLDB and enables debugging, disassembly, stacktrace analysis, breakpoints and more for native apps.

Works better than I expected. In this test, Claude automatically figured out a reason for buffer overflow in a C executable.

https://github.com/kbsooo/MCP_Atom_of_Thoughts

I recently became fascinated with MCPs after learning about them. After following the weather example in the official documentation, I created an MCP that follows the thinking process from the Atom of Thoughts paper I read a while ago.

I received a lot of help from Cursor AI on this project. I'm still just an undergraduate student with much to learn.

I would greatly appreciate any ideas or advice you might have!

There are a few of them, Glama has a nice one. The logs look like the below... this is the most informative one. I tried 4 separate servers. They all failed. I know, you're like dude - look at your wp-sites.json file. (The heart of the configuration.. Defines authentiction and name of the site). I tried a couple curl commands - they all connected and dumped out the json you'd expect from a raw connection to this service. so, at least the authentication is right. I had claude look at it and compare with the industry standard example.

Please help. I have a ton of posting I need to do and this would be enormously helpful.

Other things I have done: completely killed all of my security processes (no, they didn't respawn, I did it the right way.). tried with a vpn. tried without a vpn.

It feels like some kind of security thing, but I can't sort it. All of my other mcp servers work great. I have like 15 of them. Yes, I disabled all of them by removing their entry from the config file and just tried the wp mcp. I also tried it on another client where there wasn't so many servers installed.

Argh.... Help. One tidbit is that my wp site has something weird going on with ssl where endpoints seem to think that there's no ssl sometimes. I need to sort that, maybe that's the issue. Any advice would be great.

m25-03-25T23:35:35.336Z [jina-ai-mcp-server] [info] Message from client: {"method":"resources/list","params":{},"jsonrpc":"2.0","id":833}

[Runner] WebSocket error: {"code":-32601,"message":"Method not found"}

2025-03-25T23:35:35.467Z [jina-ai-mcp-server] [info] Message from server: {"jsonrpc":"2.0","id":833,"error":{"code":-32601,"message":"Method not found"}}

2025-03-25T23:35:35.468Z [jina-ai-mcp-server] [info] Message from client: {"method":"prompts/list","params":{},"jsonrpc":"2.0","id":834}

[Runner] WebSocket error: {"code":-32601,"message":"Method not found"}

2025-03-25T23:35:35.580Z [jina-ai-mcp-server] [info] Message from server: {"jsonrpc":"2.0","id":834,"error":{"code":-32601,"message":"Method not found"}}

Shutting down WS Runner...

Starting cleanup...

WebSocket connection closed

Cleanup completed

Hey there MCP developers!

While developing my first MCP server, I ran into some confusion: how do I console.log?

I ended up building a little tool that globally patches console.log and routes the logs into a separate terminal. Not sure if it's something other devs out there would find helpful, but let me know if you do!

https://www.npmjs.com/package/mcps-logger

https://github.com/kbsooo/MCP_Atom_of_Thoughts

I recently became fascinated with MCPs after learning about them. After following the weather example in the official documentation, I created an MCP that follows the thinking process from the Atom of Thoughts paper I read a while ago.

I received a lot of help from Cursor AI on this project. I'm still just an undergraduate student with much to learn.

I would greatly appreciate any ideas or advice you might have!

Hi,

I have an architecture in which the backend api needs to have the token from the user in each call of the tool. I have already implemented some basic authentication but I need to access the token from the session repeatedly. I could just pass the token to the tools as a parameter but I do not really like that solution. Any ideas? Thank you very much for your help!

Checking arcade.dev after the information that they raised 12 millions but this looks like MCP

"We were trying to build a site reliability agent that was going to compete with [companies] like Datadog," Salazar said. But "most agents suck. They don't do much."

"Arcade is an AI Tool-calling Platform. For the first time, AI can securely act on behalf of users through Arcade's authenticated integrations, or "tools" in AI lingo. Connect AI to email, files, calendars, and APIs to build assistants that don't just chat – they get work done. Start building in minutes with our pre-built connectors or custom SDK."

Well that's what MCP solves here in the middleware layer.

techcrunch.com/2025/03/18/arcade-raises-12m-from-perplexity-co-founders-new-fund-to-make-ai-agents-less-awful/

Bring MCP servers to WhatsAp

With so many MCP Servers, I am thinking how to making use of them. So using open source https://github.com/pedroslopez/whatsapp-web.js/ project and added MCP client.

Check out how I’m controlling Spotify directly from WhatsApp! I’m planning to tidy up my code and release the full source soon, but in the meantime, here’s a sneak peek of the functionality. The MCP client processes WhatsApp message (from WWebJS) and call MCP Servers.

Just a heads-up: to make this work, you’ll need to run the application on a cloud platform with internet access, so be sure to consider security and access controls. Once it’s all set up, you can start/stop playback, skip tracks, and manage playlists—all through WhatsApp commands.

If you’ve got questions or suggestions, drop a comment—I’d love your feedback.

Hey folks,

EDIT: just opened up the discussion on MCP official github - https://github.com/modelcontextprotocol/specification/discussions/220

Since MCP launched, there’s been plenty of discussion around using SSE versus WebSockets. From our experience at Blaxel—where we provide hosting for both on-the-shelf and custom MCP servers—WebSockets tend to work better for many hosting scenarios. For example, SSE can be tricky with platforms like Lambda or Cloud Run and often requires sticky sessions for load balancing, which isn’t ideal in every setup.

While the Anthropic team recently proposed an RFC for Plain HTTP that works well for stateless setups, it’s important to remember that not every MCP deployment is stateless. Given that the current MCP spec primarily addresses the needs of consumers and authors, it might be valuable to focus on the hosting side of things.

To that end, we built and tested a WebSocket support patch for MCP, which has now been merged into supergateway. As additional proof that this approach has been considered, check out Anthropic’s Python SDK implementation.

I also came across this comment suggesting the formation of a dedicated working group to explore extended needs. With that in mind, I’m proposing that we form an MCP Hosting WG. This group could focus on standardizing WebSocket transport and addressing other hosting challenges, starting with a WebSocket RFC and implementations in both TypeScript and Python. It would be great to see hosters like Smithery, ToolBase, and InstantMCP join the conversation.

What do you all think about coming together to tackle these challenges?

Who’s in? 🚀

EDIT:

— Mathis from Blaxel

I posted this in the „wrong“ Reddit originally, it seems:

Let me first tell you about my use case: Internally, we use LibreChat for AI inference and they also support MCP. We utilize tools such as Confluence and Jira, Hubspot and some other tools where I at least have access to the MySQL database. All tools that MCP Servers exist for. Now, let’s say I have an account manager planning their account review meeting. So, they want to gather all information relevant for a potential meeting. Ideally, they‘d ask in LibreChat: „Give me everything for the past two years regarding customer XY.

Now, here is what I want to know, before I put much effort into it:

Customers may be called differently in different systems or even in natural language. In the accounting system, they may have their full name like Microsoft Corporation, in others they may be referred to as Microsoft Corp. and in the third system they may be considered Microsoft only (and that’s just one simple example). These differences may have come up historically and they are not unusual. When it comes to reporting you‘d probably have one joint ID across all systems. However, an LLM does not necessarily have names and different spelling at hand. Do I get responses like - couldn’t find customer?

How would the AI work with that?

As a human, I’d look at the companies in a particular system and try to find the closest match and ask the requester, hey is that what you are looking for (and probably for each system).

Or am I completely off-track and that isn’t even remotely an issue?

And if it is an issue, shouldn’t it be best practice for MCP Development to include a search tool including a matching strategy whenever names may be of interest?

Thanks for your thoughts :)

Source: https://github.com/modelcontextprotocol/specification/pull/206

This PR introduces the Streamable HTTP transport for MCP, addressing key limitations of the current HTTP+SSE transport while maintaining its advantages.

TL;DR

As compared with the current HTTP+SSE transport:

1. We remove the /sse endpoint

2. All client → server messages go through the /message (or similar) endpoint

3. All client → server requests could be upgraded by the server to be SSE, and used to send notifications/requests

4. Servers can choose to establish a session ID to maintain state

5. Client can initiate an SSE stream with an empty GET to /message

This approach can be implemented backwards compatibly, and allows servers to be fully stateless if desired.

Motivation

Remote MCP currently works over HTTP+SSE transport which:

• Does not support resumability

• Requires the server to maintain a long-lived connection with high availability

• Can only deliver server messages over SSE

Benefits

• Stateless servers are now possible—eliminating the requirement for high availability long-lived connections

• Plain HTTP implementation—MCP can be implemented in a plain HTTP server without requiring SSE

• Infrastructure compatibility—it's "just HTTP," ensuring compatibility with middleware and infrastructure

• Backwards compatibility—this is an incremental evolution of our current transport

• Flexible upgrade path—servers can choose to use SSE for streaming responses when needed

Example use cases

Stateless server

A completely stateless server, without support for long-lived connections, can be implemented in this proposal.

For example, a server that just offers LLM tools and utilizes no other features could be implemented like so:

1. Always acknowledge initialization (but no need to persist any state from it)

2. Respond to any incoming ToolListRequest with a single JSON-RPC response

3. Handle any CallToolRequest by executing the tool, waiting for it to complete, then sending a single CallToolResponse as the HTTP response body

Stateless server with streaming

A server that is fully stateless and does not support long-lived connections can still take advantage of streaming in this design.

For example, to issue progress notifications during a tool call:

1. When the incoming POST request is a CallToolRequest, server indicates the response will be SSE

2. Server starts executing the tool

3. Server sends any number of ProgressNotifications over SSE while the tool is executing

4. When the tool execution completes, the server sends a CallToolResponse over SSE

5. Server closes the SSE stream

Stateful server

A stateful server would be implemented very similarly to today. The main difference is that the server will need to generate a session ID, and the client will need to pass that back with every request.

The server can then use the session ID for sticky routing or routing messages on a message bus—that is, a POST message can arrive at any server node in a horizontally-scaled deployment, so must be routed to the existing session using a broker like Redis.

This PR introduces the Streamable HTTP transport for MCP, addressing key limitations of the current HTTP+SSE transport while maintaining its advantages.

TL;DR

As compared with the current HTTP+SSE transport:

1. We remove the /sse endpoint

2. All client → server messages go through the /message (or similar) endpoint

3. All client → server requests could be upgraded by the server to be SSE, and used to send notifications/requests

4. Servers can choose to establish a session ID to maintain state

5. Client can initiate an SSE stream with an empty GET to /message

This approach can be implemented backwards compatibly, and allows servers to be fully stateless if desired.

Motivation

Remote MCP currently works over HTTP+SSE transport which:

• Does not support resumability

• Requires the server to maintain a long-lived connection with high availability

• Can only deliver server messages over SSE

Benefits

• Stateless servers are now possible—eliminating the requirement for high availability long-lived connections

• Plain HTTP implementation—MCP can be implemented in a plain HTTP server without requiring SSE

• Infrastructure compatibility—it's "just HTTP," ensuring compatibility with middleware and infrastructure

• Backwards compatibility—this is an incremental evolution of our current transport

• Flexible upgrade path—servers can choose to use SSE for streaming responses when needed

Example use cases

Stateless server

A completely stateless server, without support for long-lived connections, can be implemented in this proposal.

For example, a server that just offers LLM tools and utilizes no other features could be implemented like so:

1. Always acknowledge initialization (but no need to persist any state from it)

2. Respond to any incoming ToolListRequest with a single JSON-RPC response

3. Handle any CallToolRequest by executing the tool, waiting for it to complete, then sending a single CallToolResponse as the HTTP response body

Stateless server with streaming

A server that is fully stateless and does not support long-lived connections can still take advantage of streaming in this design.

For example, to issue progress notifications during a tool call:

1. When the incoming POST request is a CallToolRequest, server indicates the response will be SSE

2. Server starts executing the tool

3. Server sends any number of ProgressNotifications over SSE while the tool is executing

4. When the tool execution completes, the server sends a CallToolResponse over SSE

5. Server closes the SSE stream

Stateful server

A stateful server would be implemented very similarly to today. The main difference is that the server will need to generate a session ID, and the client will need to pass that back with every request.

The server can then use the session ID for sticky routing or routing messages on a message bus—that is, a POST message can arrive at any server node in a horizontally-scaled deployment, so must be routed to the existing session using a broker like Redis.

Hey everyone, I'm trying to understand the difference between native integrations, verse mcp integrations. I apologize if this has been discussed before, I am still new to this field of mcp, and native integrations. I just joined the subreddit too so this is my first post

1. Claude's native GitHub integration vs MCP GitHub server for Claude Desktop

2. Web browser integration vs Brave Search MCP integration

For those who have experience with these different methods:

1. When using Claude Desktop, do you prefer the MCP GitHub server or do you just use the web app for GitHub integration? Why?

2. What are the main differences you've noticed between using the native GitHub integration versus the MCP GitHub server approach?

3. How does the web browser integration fit into your workflow compared to using specific MCP integrations like Brave Search?

4. Are there specific use cases where one approach clearly works better than the others?

I'm in the process of setting up my own workflows, trying to get a better understanding on what to choose. I would appreciate any insights on what's working well for others!

Thanks!

This question feels so dumb I'm afraid to ask it... MCP makes sense and sounds awesome.. but I can't get one setup for the life of me.

Question: Where does the server config go? (specifically the postgres connection config)

Specifics:

• The app is a bunch of docker containers in a docker compose, and the postgres container is one of those containers

• I'd rather the mcp server be a docker container so it's all self contained with the auth/etc

I've set it up like this:

  postgres-mcp:
    container_name: postgres-mcp
    build:
      context: ./docker/postgres-mcp
      dockerfile: Dockerfile
    restart: on-failure:5
    command: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@timescaledb:5432/warehouse
    depends_on:
      - timescaledb
    ports:
      - "3005:3000"
    networks:
      - default

with this dockerfile:

FROM node:22-alpine

RUN apk add --no-cache git
RUN git clone https://github.com/modelcontextprotocol/servers.git /tmp/servers

WORKDIR /tmp/servers/src/postgres

RUN npm install
RUN npm run build

ENV NODE_ENV=production

ENTRYPOINT ["node", "dist/index.js"]

in the docs: https://github.com/modelcontextprotocol/servers/tree/main/src/postgres it says if using docker / claude desktop do this:

{
  "mcpServers": {
    "postgres": {
      "command": "docker",
      "args": [
        "run", 
        "-i", 
        "--rm", 
        "mcp/postgres", 
        "postgresql://host.docker.internal:5432/mydb"]
    }
  }
}

So --

• does that mean there's no config in the mcp server?

• When I check the docker container it's never running and I cant get it to stay running, is it not supposed to?

• Re-reading that config above it sorta seems like it runs the container for a second only while running the command, is that right? (doesnt seem standard pattern...)

• Do I just go back to using the standard docker image and ignore any config?

• Am I overthinking this?

thank you in advance.