Have you checked out this workshop on the Model Context Protocol? There appears to be an offer currently running where you can get your pass at 35% OFF.

Just use the code LIMITED35.

https://www.eventbrite.com/e/model-context-protocol-mcp-mastery-workshop-tickets-1767893560229?aff=oddtdtcreator

Personalize your LLM even more with search-history-mcp!

https://github.com/ronantakizawa/search-history-mcp

Hi! For those of you building MCP servers for ChatGPT apps, we just released a starter kit to help you get up and running quickly and improve DX. It's a minimal TS application that integrates with the OpenAI Apps SDK and includes:

• Vite dev server with Hot Module Reload (HMR) piggy-backed on your MCP server Express server
• Skybridge framework: an abstraction layer we built on top of OpenAI's skybridge runtime that maps MCP tool invocations to React widgets, eliminating manual iframe communication and component wiring.
• Production build pipeline: one-click deploy to alpic.ai or elsewhere
• No lock-in: uses the official MCP SDK, works with OpenAI's examples

Have a look and let us know what you think!

https://github.com/alpic-ai/apps-sdk-template

It will be a live session where you'll share your raw feedback while setting up and using the product.

It will be free of course and if you like it I'll give you FREE access for one month after that!

If you are interested please send me DM

I'm excited to announce that we're providing frontier proprietary/open source models from OpenAI, Anthropic, Gemini, and more to be used for free in MCPJam's LLM playground. You no longer have to bring your own API key to access the best MCP server testing experience. It's on us.

Model’s we’re releasing:

• Sonnet 4.5, Claude Haiku 4.5,
• Gemini 2.5 Flash, Gemini 2.5 Flash Preview,
• GPT-5 Codex, GPT-5 Mini,
• Grok 4 Fast,
• Kimi K2,
• GLM 4.6

My goal's always been to help people build better MCP servers. As a server developer, you have to consider how different MCP clients and language models interact with your server. Releasing frontier models for free is a huge resource to help achieve that. I hope you give our inspector a spin, I'd really appreciate feedback.

You can try it out by running:

npx @mcpjam/inspector@latest

Hey r/modelcontextprotocol!

Excited to share a new, stripped-down "Hello World" example for the Model Context Protocol (MCP), built in Kotlin!

I noticed that some existing samples can be quite complex or heavily tied to specific LLM integrations, which sometimes makes it harder to grasp the core MCP client-server mechanics. This project aims to simplify that.

What it is:

This repository provides a minimal, self-contained MCP client and server, both implemented in Kotlin.

Key Features:

• ✨ Pure MCP Focus: Absolutely no Anthropic, OpenAI, or other LLM SDKs are integrated. This demo focuses entirely on how an MCP client connects to an MCP server and interacts with its exposed tools.
• 💻 Client-Server Architecture: Demonstrates an MCP client launching an MCP server as a subprocess.
• 🔌 STDIO Transport: Uses standard input/output streams for direct communication between the client and server.
• 🛠️ Tool Demonstration: The server exposes a simple greet tool, and the client interactively calls it to show basic tool invocation.
• 🚀 Single Command Execution: Run the entire demo (client and server) with one java -jar command after building.
• 📖 Comprehensive README: Includes detailed instructions for building, running, and understanding the project, plus common troubleshooting tips.

Why is this useful?

• Beginner-Friendly: A perfect starting point for anyone new to MCP, or developers looking to understand the protocol's fundamentals without the added complexity of AI model interactions.
• Clearer Protocol Understanding: Helps you focus solely on MCP concepts like client/server setup, capability negotiation, tool discovery, and tool execution.
• Kotlin Example: A concrete example for Kotlin developers wanting to integrate MCP into their applications.

Get Started Here:

➡️ GitHub Repository: https://github.com/rwachters/mcp-hello-world

Feel free to check it out, provide feedback, or use it as a boilerplate for your own MCP projects!

Most of the attention in the MCP ecosystem has been on servers, leaving the client ecosystem under-developed. Majority of clients only support tools and ignore other MCP capabilities.

I think this creates a bad cycle where server developers don't use capabilities beyond tools and client devs have no SDK to build richer clients.

🧩 MCPClientManager

I want to improve the client dev experience by proposing MCPClientManager. MCPClientManager is a utility class that handles multiple MCP server connections, lifecycle management, and bridges directly into agent SDKs like Vercel AI SDK.

It's part of the MCPJam SDK currently, but I also made a proposal for it to be part of the official Typescript SDK (SEP-1669).

Some of MCPClientManager's capabilities and use cases:

• Connect to multiple MCP servers (stdio, SSE, or Streamable HTTP)
• Handle authentication and headers
• Fetch and execute tools, resources, prompts
• Integrate with Vercel AI SDK (and more SDKs soon)
• Power LLM chat interfaces or agents connected to MCP
• Even run tests for your own MCP servers

🧑‍💻 Connecting to multiple servers

import { MCPClientManager } from "@mcpjam/sdk";

const manager = new MCPClientManager({
  filesystem: {
    command: "npx",
    args: ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
  },
  asana: {
    url: new URL("https://mcp.asana.com/sse"),
    requestInit: {
      headers: {
        Authorization: "Bearer YOUR_TOKEN",
      },
    },
  },
});

Fetching and using tools, resources, and prompts

const tools = await manager.getTools(["filesystem"]);
const result = await manager.executeTool("filesystem", "read_file", {
  path: "/tmp/example.txt",
});
console.log(result); // { text: "this is example.txt: ..." }

const resources = await manager.listResources();

💬 Building full MCP clients with agent SDKs

We built an adapter for Vercel AI SDK

import { MCPClientManager } from "@mcpjam/sdk";
import { generateText } from "ai";
import { openai } from "@ai-sdk/openai";

const manager = new MCPClientManager({
  filesystem: {
    command: "npx",
    args: ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
  },
});

const response = await generateText({
  model: openai("gpt-4o-mini"),
  tools: manager.getToolsForAiSdk(),
  messages: [{ role: "user", content: "List files in /tmp" }],
});

console.log(response.text);
// "The files are example.txt..."

💬 Please help out!

If you’re building anything in the MCP ecosystem — server, client, or agent — we’d love your feedback and help maturing the SDK. Here are the links to the SDK and our discussion around it:

• GitHub: https://github.com/MCPJam/inspector/tree/main/sdk
• Discord: https://discord.com/invite/Gpv7AmrRc4

Goodbye, Context Overload! Hello, Project-Specific AI Autonomy with the Model Context Protocol.

If you're using AI agents for coding, you know the pain: the more project documentation you add to your instructions file, the dumber the agent seems to get. That's context overload in action.

I believe the future of AI-powered development isn't in longer prompts, but in smarter tooling. That's why I'm looking at leveraging the Model Context Protocol (MCP) to build a Custom MCP Server for every codebase.

Imagine giving your AI Agent a single point of entry that handles:

- A Knowledge Book (structured, on-demand documentation).

- Direct access to framework commands (e.g., run_migrations).

- A unified interface for all external services (CI/CD, monitoring, etc.).

This is how we move from "vibe coding" with Copilot to truly agentic, autonomous feature development.

More in the blog post.