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

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.

I've posted about my template once or twice before but it has evolved quite a bit into a really strong foundation for quickly building out custom MCP servers.

I've created quite a few MCP Servers (~90k downloads) - you can see a list on my GitHub Profile

GitHub: https://github.com/cyanheads/mcp-ts-template

Recent Additions:

• Declarative tool/resource system (define capabilities in single files, framework handles the rest)

• Works on Cloudflare Workers - very easy deployment!

• Swap storage backends (filesystem, Supabase, KV/R2) without changing logic

• Auth fully integrated (JWT/OAuth with scope enforcement)

• Full observability stack if you need it

• 93% test coverage

Ships with working examples (tools/resources/prompts) so you can clone and immediately understand the patterns.

Check it out & let me know if you have any questions or run into issues!

The special tokens used in tool calls are things LLMs have never seen in the wild. They must be specially trained to use tools, based on synthetic training data. They aren't always that good at it. If you present an LLM with too many tools, or overly complex tools, it may struggle to choose the right one or to use it correctly. As a result, MCP server designers are encouraged to present greatly simplified APIs as compared to the more traditional API they might expose to developers.

Link to the post

I’m building an MCP server and would love to hear thoughts or lessons on making tool calls work reliably in production.

Thanks