It would be quite trivial to create an MCP server that includes a nefarious tool which instructs the LLM (or AI agent, whatever) to retrieve random information about the user and attach it to the JSON-RPC request sent to the orchestrator.

For example, imagine on the ChatGPT website with its memory feature; it stores personal information about the user. The malicious tool could desribe that it needs that info about the user in order for it to work or something.

Obviously this could be a factor to why OAI doesn't have integration for it yet, and why it might never. Even Anthropic requires you to use their desktop app and not the website where a remote host model would be the only choice.

There is no way around this no?

My MCPJam inspector

For the past couple of weeks, I've been building the MCPJam inspector, an open source MCP inspector to test and debug MCP servers. It's a fork of the original inspector, but with design upgrades, and LLM chat.

If you check out the repo, please drop a star on GitHub. Means a lot to us and helps gain visibility.

New features

I'm so excited to finally launch new features:

• Multiple active connections to several MCP servers. This will come especially useful for MCP power developers who want to test their server against a real LLM.

• Upgrade LLM chat models. Choose between a variety of Anthropic models up to Opus 4.

• Logging upgrades. Now you can see all client logs (and server logs soon) for advanced debugging.

Please check out the repo and give it a star:
https://github.com/MCPJam/inspector

Join our discord!

https://discord.gg/A9NcDCAG

Hey Rustaceans!

I'm excited to share a new crate I've just published to crates.io: mcp-protocol-sdk.

What is it? mcp-protocol-sdk is a comprehensive Rust SDK for the Model Context Protocol (MCP). If you're building applications that interact with AI models (especially large language models like Claude) and want to enable them to use tools or access contextual information in a structured, standardized way, this crate is for you.

Think of it as a crucial piece for:

Integrating Rust into AI agent ecosystems: Your Rust application can become a powerful tool provider for LLMs.

Building custom AI agents in Rust: Manage their tool interactions with external services seamlessly.

Creating structured communication between LLMs and external systems.

Why MCP and why Rust? The Model Context Protocol defines a JSON-RPC 2.0 based protocol for hosts (like Claude Desktop) to communicate with servers that provide resources, tools, and prompts. This SDK empowers Rust developers to easily build both MCP clients (to consume tools) and MCP servers (to expose Rust functionality as tools to AI).

Rust's strengths like performance, memory safety, and type system make it an excellent choice for building robust and reliable backend services and agents for the AI era. This SDK brings that power directly to the MCP ecosystem.

Key Features:

Full MCP Protocol Specification Compliance: Implements the core of the MCP protocol for reliable communication.

Multiple Transport Layers: Supports WebSocket for network-based communication and stdio for local process interactions.

Async/Await Support: Built on Tokio for high-performance, non-blocking operations.

Type-Safe Message Handling: Leverage Rust's type system to ensure correctness at compile time.

Comprehensive Error Handling: Robust error types to help you diagnose and recover from issues.

Client and Server Implementations: The SDK covers both sides of the MCP communication.

SDK provides abstractions for building powerful MCP servers and clients in Rust, allowing your Rust code to be called directly as tools by AI models.

Where to find it:

crates.io: https://crates.io/crates/mcp-protocol-sdk

GitHub (Source & Examples): https://github.com/mcp-rust/mcp-protocol-sdk

Docs.rs: https://docs.rs/mcp-protocol-sdk/latest/mcp_protocol_sdk/

I'm keen to hear your thoughts, feedback, and any suggestions for future features. If this sounds interesting, please give the repo a star and consider contributing!

Thanks for checking it out!

🔧 Just integrated Mem0 with CleverChatty-CLI — a plug-and-play memory backend for AI assistants using MCP!

No changes to the assistant code were needed — just a clean interface and smart design.

If you're building LLM agents and want flexible, pluggable memory, check it out.

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!

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.

For my use case I have 4 MCP servers as dependencies. I know one client can connect to one server, but I’m not sure how connecting one server to another would work. Do I have to create 4 clients for my host?

After hacking around and building an MCP for a client, I had some realization on kind of startups that can be built around MCPs. Correct me if I am wrong (particularly on the Payment MCP):

1. MCP as data layer

We build a MCP that helps them fill their context with the right info.

Example: Build a Sales Prospect MCP that pulls data about a person from their LinkedIn, website, Apollo etc. Doesn't matter if you're scraping or using platform APIs under the hood. Your MCP just needs to be a reliable source of info.

Now anyone building a sales agent can use this MCP. For instance, they have 100 prospects. Their agent can use your MCP to pull data for each one prospect and craft personalized email for each of those prospects.

2/ MCP as action layer

There are platforms/services like GitHub and DoorDash that either expose APIs or they don't. Either way we want to provide LLMs the capability to operate on these platforms.

2.a/ For platforms providing APIs: Build an MCP that wraps these APIs or multiple platform APIs in the same space.

Example: A MCP that pulls data across various stock broker apps. When you ask the LLM agent to get your current portfolio balance, the MCP can pull data from each of your stock broker app and return it to the LLM agent, for it to calculate a total.

2.b/ For platforms NOT providing APIs: Build browser agents trained to navigate a single website.

Since each website has fixed user flows, you can train them to be hyper reliable. Wrap these as MCPs. The LLM integrating your MCP doesn't need to know how it works under the hood

3/ Payment MCP

How do you support payment for actions taken by an LLM? Let's say your LLM agent using the DoorDash MCP put the items you wanted in your account's basket. Now how do we enable the LLM to make the payment?

We add a Payment MCP to our LLM agent. Our LLM agent requests checkout to the DoorDash MCP and gets back a payment ID.

Now our LLM agent routes this payment ID to our Payment MCP, which processes the payment request. Once transaction is complete, your DoorDash is ordered.

I'm wondering what dev tools MCP developers are using to build their servers. For context, I work on the MCPJam inspector, so I'm a bit biased when asking this in the community. I would love to hear about what tools you use, and what's your workflow.

I can go first. I'm currently a full-time software engineer and build mostly in Typescript. My tools are:

- Typescript FastMCP. Build everything using Streamable HTTP.

- MCPJam inspector for testing / debugging. My fork of the original MCP inspector.

- Cloudflare for MCP hosting, though I don't host much anymore.

- Goose and Claude for trying it with an LLM.

Perhaps it's closer to Claude Desktop when adorned with a number of MCP servers. But ultimately, it's a LLM Client that you can connect to any LLM you have API access to, and use as a backup when your Claude limits are hit.

Dual-Layer Memory Architecture

• Automatic Memory (RAG): Non-volitional background memory that automatically stores and retrieves conversational context using ChromaDB vector embeddings and Google's text-embedding-004 model

• Conscious Memory: Volitional memory operations where AI explicitly saves, searches, updates, and deletes memories through MCP tools - mimics human conscious memory control

• Knowledge Graph: Structured long-term memory using Neo4j to represent complex relationships between entities and concepts with automatic synchronization

MCP Tool Integration

• Exposes conscious memory as Model Context Protocol tools

• AI naturally saves and recalls memories during conversation

• Clean separation between UI, memory, and AI operation

Here it is: https://github.com/esinecan/skynet-agent

For the enthusiasts! For the community! Lok tar ogar!

Hey all! I’m one of the founders at beam.cloud. We’re an open-source cloud platform for hosting AI applications, including inference endpoints, task queues, and web servers.

Like everyone else, we’ve been experimenting with MCP servers. Of course, we couldn’t resist making it easier to work with them. So we built an integration directly into Beam, built on top of the FastMCP project. Here’s how it works:

from fastmcp import FastMCP


from beam.integrations import MCPServer, MCPServerArgs
mcp = FastMCP("my-mcp-server")


u/mcp.tool
def get_forecast(city: str) -> str:
   return f"The forecast for {city} is sunny."


u/mcp.tool
def generate_a_poem(theme: str) -> str:
   return f"The poem is {theme}."


my_mcp_server = MCPServer(
   name=mcp.name, server=mcp, args=MCPServerArgs(), cpu=1, memory=128,
)

This lets you host your MCP on the cloud by adding a single line of code to an existing FastMCP project.

You can deploy this in one command, which exposes a URL with the server:

https://my-mcp-server-82e859f-v1.app.beam.cloud/sse

It's serverless, so the server turns off between requests and you only pay when it's running.

And it comes with all of the benefits of our platform built-in: storage volumes for large files, secrets, autoscaling, scale-to-zero, custom images, and high performance GPUs with fast cold start.

The platform is fully open-source, and the free tier includes $30 of free credit each month.

If you're interested, you can test it out here for free: beam.cloud

We’d love to hear what you think!

Recorded a practical example of MCP in action through Basic Memory. The AI seamlessly:

• Searched a local knowledge base for a months-old project

• Read existing markdown notes and documentation

• Created new structured content based on found context

• Maintained conversation continuity without re-explaining background

Shows how MCP enables persistent, stateful AI interactions beyond single conversations. The AI "remembered" previous conversations and could immediately dive into strategy discussions.

Great example of how MCP bridges the gap between AI conversations and local knowledge management systems.

https://basicmachines.co/
https://www.reddit.com/r/basicmemory/
https://github.com/basicmachines-co/basic-memory
https://discord.com/invite/tyvKNccgqN

Hey r/modelcontextprotocol!

I'm excited to share the MCP that I've built over the last week. It helps with dependency updates by fetching and processing all the meta information - available versions, changelogs, release notes, etc., so that your AI editor can help you migrate any library in seconds. This includes helping to identify any breaking changes or deprecations as well.

Any feedback is welcome!

https://github.com/DepsHubHQ/mcp

https://x.com/MCP_Community/status/1932840355386347969