DEV Community: Jialu

We Got Tired of LLMs Getting LeanMCP Wrong. So We Built Our Own Agent

Jialu — Tue, 10 Mar 2026 09:44:03 +0000

It took 2 hours. It runs on our own platform. And it knows our docs better than ChatGPT.

Every time someone asked ChatGPT or Claude how to use LeanMCP, we'd wince. The answers were close enough to sound credible, but wrong enough to waste an hour of a developer's time.

So we did something about it.

The Problem

General-purpose LLMs have a knowledge cutoff. They know LeanMCP exists. They've seen some of our public docs. But they don't know the details - the specific package names, the exact API patterns, the two We Got Tired of LLMs Getting LeanMCP Wrong. So We Built Our Own Agent

It took 2 hours. It runs on our own platform. And it knows our docs better than ChatGPT.

Every time someone asked ChatGPT or Claude how to use LeanMCP, we'd wince. The answers were close enough to sound credible, but wrong enough to waste an hour of a developer's time.

So we did something about it.

The Problem

General-purpose LLMs have a knowledge cutoff. They know LeanMCP exists. They've seen some of our public docs. But they don't know the details - the specific package names, the exact API patterns, the two different ways OAuth works depending on your setup.

When someone asks "how do I add OAuth to my LeanMCP server?", ChatGPT gives one answer and hopes for the best. It might be right. It might be slightly wrong. You won't know until you try it and it breaks.

That's not good enough.

What We Built

We built an AI agent that lives on leanmcp.com. It has access to:

LeanMCP docs
LeanMCP blog posts
Internal resources and changelogs

Ask it anything about LeanMCP and it gives you a cited, accurate answer - with links to the exact docs page it's referencing.

It took us 2-3 hours to build and deploy.

The Difference in Practice

Same question. Two very different answers.

Question: "How do I set up observability on LeanMCP?"

ChatGPT's answer was long, technically detailed, and spent half its response explaining how to set up monitoring on Vercel, AWS, GCP, and Azure - things that are completely irrelevant if you're deploying on LeanMCP Platform.

Our agent asked the right question first: "Observability on LeanMCP comes in two layers - which one do you mean?" Then it covered both, concisely, with the exact code snippet and a citation to the right docs page.

Question: "How do I add OAuth to my LeanMCP server?"

ChatGPT gave one OAuth path. Our agent recognized the ambiguity, explained two common scenarios, and gave complete working code for each - including the @Authenticated\ decorator pattern and the exact authUser.sub\ field you need downstream.

ChatGPT got close. Our agent got it right.

But First: How Do You Know It's Actually Accurate?

Before we shipped, we built a benchmark. 19 categories, ~130 questions - covering everything from onboarding to OAuth, pricing, deployment, debugging, enterprise qualification, and even investor questions. We ran every question through the agent and reviewed the results.

Zero errors across all 19 categories.

That's not luck. That's what happens when you build an agent on top of your own infrastructure, with your own knowledge base, and actually measure the output before you ship it.

How We Built It

We used our own platform to build this. Here's what it took:

Defined the knowledge base - LeanMCP docs, blog posts, and internal resources, structured so MCP tools can search them efficiently
Built MCP search tools - A few tools that can retrieve relevant content from different internal sources, with proper ranking and citation
Chose the model - We tested several. GPT ended up being the best fit for this use case: it handles web search well and produces clean, properly cited responses
Deployed on LeanMCP - The agent runs on our own infrastructure, using our own managed deployment platform
Plugged in observability - We use app.leanmcp.com to see every question users ask in real time. This tells us what people are confused about and where our docs need work

The whole thing - from idea to live - was an afternoon.

Why This Matters

This isn't just a customer support chatbot. It's proof that LeanMCP is the fastest way to take your internal knowledge and turn it into a deployed, observable AI agent.

We built ours in 2 hours. You can build yours for your own product, your own internal tools, your own customer base.

If you want to see what it looks like, try the agent on leanmcp.com

If you want to build something similar - especially with private data or custom integrations - talk to us

LeanMCP is production-grade MCP infrastructure: SDK + managed deployment + observability. Get started

MCP Apps: AI Agents Just Became Applications - Here's How to Build One

Jialu — Thu, 19 Feb 2026 13:13:16 +0000

MCP Apps (SEP-1865) is the open standard that lets AI agents render interactive UIs inside the conversation. Cross-platform, backed by Anthropic + OpenAI, live in Claude and ChatGPT today. Here's how to build one that actually runs in production."

AI agents just crossed a line.

For years, every agent output was the same: text. Need to show a dashboard? Return JSON. Need a 20-field config form? Walk the user through each field, prompt by prompt. Need a product catalog? Describe it.

That era is over.

MCP Apps - the first official extension to the Model Context Protocol, co-authored by Anthropic and OpenAI - lets your MCP server return fully interactive HTML interfaces that render directly inside Claude, ChatGPT, VS Code, and Goose. Not in a new tab. Not alongside the conversation. Inside it.

This post covers how it works, how to build one with LeanMCP, and what it takes to run one in production.

Why "Text Wall" Was Always the Hard Ceiling

The problem isn't just UX. It's capability.

Commerce, data exploration, multi-step approval workflows, complex configuration - none of these map cleanly to a chat thread. You can approximate them with text. You can't actually do them well.

MCP Apps solves this with a security-first architecture:

Pre-declared UI resources registered in the server manifest - hosts review and cache them before any tool is called
Sandboxed iframes that isolate third-party code from the host application
Bidirectional communication via existing MCP JSON-RPC over postMessage - no new SDKs, no new transport
Full backward compatibility - text-only fallbacks for clients that don't yet support UI

How It Works

At connection time, your server declares UI resources in the manifest. The host pre-fetches and caches them.
The AI invokes a tool. If that tool has an associated UI resource URI, the host renders a UI.
The host loads HTML into a sandboxed iframe. The UI hydrates with the tool's input and output data.
The user interacts. The iframe communicates back to the host - and to the model - via JSON-RPC over postMessage.

You control exactly what the model sees vs. what the view sees. Sensitive data can pass to the view without polluting the model's context window.

Building an MCP App with LeanMCP

LeanMCP handles the production layer - auth, observability, multi-tenancy - so you can focus on the interface itself.

Step 1: Create your project

npm install -g @leanmcp/cli
npx @leanmcp/cli create my-mcp-app
cd my-mcp-app
npm install

This generates a clean structure:

my-mcp-app/
├── main.ts              # Entry point
├── package.json
├── tsconfig.json
└── mcp/
    └── example/
        └── index.ts     # Your services go here

Step 2: Define your tool

// mcp/analytics/index.ts
import { Tool, SchemaConstraint, Optional } from "@leanmcp/core";

class SalesReportInput {
  @SchemaConstraint({ description: "Region to filter by", minLength: 1 })
  region!: string;

  @Optional()
  @SchemaConstraint({
    description: "Date range",
    enum: ["7d", "30d", "90d"],
    default: "30d"
  })
  range?: string;
}

export class AnalyticsService {
  @Tool({
    description: "Get sales report data",
    inputClass: SalesReportInput
  })
  async getSalesReport(args: SalesReportInput) {
    const data = await fetchSalesData(args.region, args.range);

    // Return data - your MCP Apps UI resource
    // is registered separately in the server manifest
    return {
      region: args.region,
      totalRevenue: data.revenue,
      topProducts: data.products,
      chartData: data.chart
    };
  }
}

Step 3: Configure the HTTP server with logging

// main.ts
import { createHTTPServer } from "@leanmcp/core";

await createHTTPServer({
  name: "my-mcp-app",
  version: "1.0.0",
  port: 8080,
  cors: true,
  logging: true,      // tool calls, latency, errors - all tracked
  autoDiscover: true  // picks up everything in ./mcp automatically
});

Your server is live at http://localhost:8080/mcp.

Step 4: Add auth - one decorator

// mcp/analytics/index.ts
import { Tool, SchemaConstraint } from "@leanmcp/core";
import { AuthProvider, Authenticated } from "@leanmcp/auth";

const authProvider = new AuthProvider('cognito', {
  region: process.env.AWS_REGION,
  userPoolId: process.env.COGNITO_USER_POOL_ID,
  clientId: process.env.COGNITO_CLIENT_ID
});
await authProvider.init();

// Entire service is protected - token validated automatically
// from _meta.authorization.token in each request
@Authenticated(authProvider)
export class AnalyticsService {
  @Tool({
    description: "Get sales report - authenticated users only",
    inputClass: SalesReportInput
  })
  async getSalesReport(args: SalesReportInput) {
    // No token parsing needed here - LeanMCP handles it
    return { data: await fetchSalesData(args.region) };
  }
}

Step 5: Add a new service anytime

leanmcp add dashboard
# Creates mcp/dashboard/index.ts with boilerplate
# Auto-registers in main.ts
# Ready to customize immediately

MCP Apps vs GPT Apps - Why Open Wins

OpenAI's GPT Apps launched in October 2025 with an impressive partner list. But it's ChatGPT-only, proprietary, and controlled by one company.

MCP Apps is an open standard, jointly governed by the MCP UI Community Working Group.

	GPT Apps	MCP Apps	With LeanMCP
Platform	ChatGPT only	Claude, ChatGPT, VS Code, Goose	Both, one server
Standard	Proprietary (OpenAI)	Open (SEP-1865)	Supports both
Auth	Not included	Not included	✅ `@Authenticated` decorator
Observability	Not included	Not included	✅ `logging: true`
Multi-tenancy	Your problem	Your problem	✅ Per-user API keys built in
Type safety	Manual	Manual	✅ `@SchemaConstraint` decorators
Service discovery	Manual	Manual	✅ `autoDiscover: true`

The same LeanMCP server covers both ecosystems. One codebase, full coverage.

The Production Gap Nobody Talks About

The MCP spec gives you the protocol. It does not give you:

Multi-tenant auth - how do you authenticate each user separately?
Per-user tracking - who's consuming your API budget?
Secrets management - how do you inject API keys safely per-request?
Audit trails - for compliance, who did what and when?
Type-safe schemas - catch input errors before they reach your tool logic
Observability - when something breaks at 2am, how do you even know?

LeanMCP is purpose-built for this gap. It's the production runtime layer underneath your MCP App - not a framework on top, not another abstraction. The ground your agent runs on.

Here's what you get with one config line:

// Logging ON = dashboards for tool calls, latency, errors, per-user usage
await createHTTPServer({
  name: "my-mcp-app",
  version: "1.0.0",
  logging: true
});

And the complete auth flow that usually takes a week to implement:

// Client calls your tool like this:
await mcpClient.callTool({
  name: "getSalesReport",
  arguments: { region: "APAC" },
  _meta: {
    authorization: {
      type: "bearer",
      token: "user-jwt-token"
    }
  }
});

// LeanMCP validates the token automatically.
// Your tool only runs if auth passes.
// No middleware code needed on your end.

Real-World Use Cases

What MCP Apps actually unlocks:

📊 Data exploration - Sales analytics tool returns a live dashboard. Filter by region, drill into accounts, export - without leaving the conversation
⚙️ Configuration wizards - Selecting 'production' reveals security options dynamically. No sequential prompts
📄 Document review - Contract tool displays PDF inline with highlighted clauses. Approve or flag in real time
🛒 Commerce - Interactive product catalogs, size selectors, cart flows embedded in agent conversations
📡 Real-time monitoring - Server health tool shows live metrics without re-running the tool

As of January 2026, officially supported in Claude (web + desktop), ChatGPT, Goose, and VS Code Insiders.

The Full Agent Stack

MCP Apps completes the platform:

Layer	Technology
Tools - what agents can do	MCP protocol
Auth - who can use them	OAuth in MCP spec
UI - what users see	MCP Apps (SEP-1865)
Runtime - how it all runs in production	LeanMCP

The ext-apps repository already includes working examples: threejs-server for 3D visualization, map-server for interactive maps, pdf-server for document viewing, system-monitor-server for live dashboards.

TL;DR

🚀 MCP Apps = interactive UIs inside Claude, ChatGPT, VS Code, Goose - open standard
🔓 Unlike GPT Apps, cross-platform: write once, run everywhere
⚡ LeanMCP = production runtime - auth, observability, type safety, multi-tenancy, all built in
🛠️ One LeanMCP server covers both GPT Apps and MCP Apps

# Start in 60 seconds
npm install -g @leanmcp/cli
npx @leanmcp/cli create my-mcp-app
cd my-mcp-app && npm start
# -> http://localhost:8080/mcp

Links:

🔗 LeanMCP GitHub - open source, MIT licensed
📖 Docs
🌐 leanmcp.com
💬 Discord

Building an MCP App? Drop a comment - would love to see what you're working on. 👇

GPT Apps: How OpenAI Is Turning ChatGPT Into an App Platform & How to Build One in Production

Jialu — Thu, 19 Feb 2026 12:19:59 +0000

OpenAI just opened the ChatGPT App Directory to public submissions.

800+ million users. Interactive UIs embedded directly in chat conversations. A builder revenue program in progress.

If you've been building AI agents with MCP, you're closer to shipping a GPT App than you think. This post covers how GPT Apps work, how they compare to MCP Apps, and — critically — what it takes to actually run one in production.

What Are GPT Apps?

GPT Apps are interactive applications that run inside ChatGPT - not in a new tab, not alongside it. When a user asks ChatGPT to find a hotel, Booking.com's booking interface appears right there in the conversation. When a user wants to edit a slide, Canva opens inline.

Launched in October 2025 with pilot partners including Booking.com, Canva, Figma, Spotify, and Shopify. The ChatGPT App Directory opened for public submissions in December 2025.

The SDK is built on top of the Model Context Protocol. If you know MCP, you already have a head start.

How GPT Apps Work (The Technical Bit)

The architecture will feel familiar if you've worked with MCP Apps:

1. UI resources are pre-declared
Widget HTML is registered upfront in your MCP server manifest — OpenAI reviews assets before publication and uses this for caching.

2. Double iframe sandboxing
ChatGPT runs a sandboxed outer iframe first, which then loads your UI in an inner iframe. Third-party code is isolated from the ChatGPT application.

3. window.openai API
OpenAI provides a clean host API for host-guest communication:

window.openai.toolInput          // tool's input parameters
window.openai.toolOutput         // tool's response
window.openai.sendFollowUpMessage({ prompt })  // message the model
window.openai.callTool(name, args)             // trigger a tool call
window.openai.widgetState        // persist state across tool calls
window.openai.widgetSessionId    // persist state across sessions

State persistence is a notable GPT Apps advantage — MCP Apps doesn't support this yet.

GPT Apps vs MCP Apps — You Don't Have to Choose

Both are built on MCP. Both solve the same "text wall" problem. The differences:

	GPT Apps	MCP Apps	With LeanMCP
Platform	ChatGPT only	Claude, ChatGPT, VS Code, Goose	Both, one server
Standard	Proprietary (OpenAI)	Open (SEP-1865)	Supports both
Auth	Not included	Not included	✅ Built in
Observability	Not included	Not included	✅ Built in
State persistence	✅ Supported	Not yet	Handled at runtime
Auto-scaling	Your problem	Your problem	✅ Auto-scaled
Deploy	Manual	Manual	✅ One CLI command

The same LeanMCP server that powers your GPT App can serve MCP Apps clients — Claude, VS Code, Goose — without additional work. One codebase, full ecosystem coverage.

Building a GPT App with LeanMCP

Here's how fast you can go from zero to a production-ready GPT App:

Step 1: Create your project

npm install -g @leanmcp/cli
npx @leanmcp/cli create my-gpt-app
cd my-gpt-app

Step 2: Define your tool with a UI resource

// mcp/hotels/index.ts
import { Tool, SchemaConstraint } from "@leanmcp/core";

class HotelSearchInput {
  @SchemaConstraint({ description: "City to search hotels in" })
  city!: string;
}

export class HotelService {
  @Tool({ description: "Search hotels with interactive UI" })
  async searchHotels(args: HotelSearchInput) {
    const hotels = await fetchHotels(args.city);

    // Return a UI resource — renders as interactive iframe in ChatGPT
    return {
      type: "ui-resource",
      html: renderHotelWidget(hotels)
    };
  }
}

Step 3: Add auth (one decorator)

import { AuthProvider, Authenticated } from "@leanmcp/auth";

const auth = new AuthProvider('cognito', {
  region: process.env.AWS_REGION,
  userPoolId: process.env.COGNITO_USER_POOL_ID,
  clientId: process.env.COGNITO_CLIENT_ID
});
await auth.init();

@Authenticated(auth)
export class HotelService {
  // Token validated automatically — no middleware needed
}

Step 4: Deploy

leanmcp deploy
# ✓ Building MCP server...
# ✓ Running type checks...
# ✓ Deploying to edge network...
# 🚀 Live at https://your-app.leanmcp.com

Auth, scaling, observability: included.

The Production Gap Nobody Talks About

The ChatGPT Apps SDK is genuinely approachable. Basic React + a working MCP server is enough to get started.

But "easy to build" and "production-ready" are different problems.

The SDK gives you the UI layer. It does not give you:

Multi-tenant auth - how do you authenticate each user separately?
Per-user cost tracking — who's consuming your API budget?
Secrets management — how do you inject API keys safely per-request?
Audit trails — what did each user's agent do, and when?
Auto-scaling — what happens at 10,000 concurrent users?
Observability — when something breaks at 2am, how do you know?

This is where most teams hit friction. LeanMCP closes that gap — it's the production runtime layer underneath your GPT App.

One line for full observability:

await createHTTPServer({
  name: "my-gpt-app",
  version: "1.0.0",
  port: 8080,
  logging: true   // dashboards: tool calls, latency, cost, user requests
});

What You Need to Submit to the App Directory

OpenAI's review checklist:

✅ MCP connectivity details
✅ Testing guidelines for reviewers
✅ Directory metadata (name, description, category)
✅ Country availability settings
✅ Privacy policy (mandatory)
✅ Compliance with OpenAI's usage policies

Both automated and human review are applied. Early movers get priority placement — the Directory is open now.

Real-World Use Cases from Launch

The pilot partners show the range of what's possible:

Booking.com — filter, compare, and book hotels without leaving ChatGPT
Canva — slide editing inline, no tab-switching
Figma — design review in conversation context
Spotify — music discovery as conversational UI
Shopify — interactive product catalogs and cart flows

Every one of these companies needed the same production layer underneath: auth, observability, scaling, secrets management.

TL;DR

🚀 GPT Apps = interactive UIs inside ChatGPT, built on MCP, 800M+ users
🔧 If you know MCP, you can start building today
⚡ The same LeanMCP server works for both GPT Apps and MCP Apps
🔒 The production gap (auth, observability, scaling) is real — LeanMCP closes it

# Get started now
npm install -g @leanmcp/cli
npx @leanmcp/cli create my-gpt-app

Links:

🔗 LeanMCP GitHub — open source, MIT licensed
📖 Docs
🌐 leanmcp.com

Drop a comment if you're building a GPT App — would love to see what you're working on. 👇

LeanMCP: Run AI Agents in Production. Own Your Stack

Jialu — Thu, 19 Feb 2026 05:46:34 +0000

Getting an AI agent to work is easy. Getting it to production is a different story.
You wire up your tools, the agent responds, the demo looks great. Then reality hits:

How do you handle user auth?
How do you isolate permissions across multiple tenants?
How do you inject secrets securely?
When something breaks at 2am, how do you even know what went wrong?

The AI agent ecosystem has frameworks, model providers, and tool integrations covered. What it's been missing is a runtime: the layer that handles governance, security, and deployment so your agent can actually run in production, at scale, without being locked into any single vendor.
That's what we built. And today we're open-sourcing it.

The Gap Between Demo and Production

Building an AI agent is the easy part. The hard part is everything that comes after.

Authentication. Multi-tenancy. Secret injection. Observability. Protocol compatibility across clients. These aren't glamorous problems, but they're the ones that decide whether your agent ships or stays a demo forever.

The MCP protocol gives you a standard way to connect tools to agents — but it doesn't tell you how to handle any of this. You're left to build it yourself, from scratch, for every project. And if you switch LLM providers or deployment environments down the road, you might rebuild it all again.

We've seen this pattern too many times. So we built the runtime that handles it.

What LeanMCP Handles

LeanMCP is an open-source agent runtime with a production-grade governance layer built in. Think of it as the operating system for your AI agents — the foundation that lets them run anywhere, work with any client, and stay secure at scale.

The problem you hit	What LeanMCP handles
User authentication	Auth0, Supabase, Cognito, Firebase — one decorator, done
Multi-tenancy	Per-user API keys and permission scoping
Secret injection	Per-request env vars, no global pollution
Production observability	Logging, monitoring, audit trails
Client compatibility	Claude Desktop, Cursor, Windsurf — HTTP/SSE/WebSocket
Governance	Security policies, access control, compliance-ready audit logs

The core SDK is open source, MIT licensed. Fork it, modify it, self-host it. The production platform — managed deployment, security governance, elastic auto-scaling across 30+ edge regions — is where we run a business. The foundation is free. The enterprise layer is where serious teams invest.

From Zero to Running in 10 Minutes

npm install -g @leanmcp/cli
npx @leanmcp/cli create my-agent
cd my-agent && npm start

Your agent runtime is live at http://localhost:8080/mcp.

Adding authentication takes one decorator:

import { AuthProvider, Authenticated } from "@leanmcp/auth";

const auth = new AuthProvider('cognito', {
  region: process.env.AWS_REGION,
  userPoolId: process.env.COGNITO_USER_POOL_ID,
  clientId: process.env.COGNITO_CLIENT_ID
});
await auth.init();

@Authenticated(auth)
export class MyService {
  @Tool({ description: "Authenticated users only" })
  async doSomething(args: { input: string }) {
    return { result: "done" };
  }
}

No custom middleware. No manually parsing auth headers. No deep-diving into protocol internals. You write the logic that matters. We handle the runtime.

Zero Vendor Lock-in Is a Design Principle, Not a Feature

We support every major agent client — Claude Desktop, Cursor, Windsurf — and every transport protocol: HTTP, SSE, WebSocket. Your agents run on our edge network or your own infrastructure. You're never forced to choose our deployment just to get our governance layer.

We don't want to be the thing that locks you in. We've watched developers get burned by betting early on a single vendor's SDK, then facing deprecations or price hikes they didn't see coming. The AI space moves too fast to assume today's best option stays that way.

If we build this well enough, you won't want to leave. But you always can.

Where We Are Today

Open-source SDK: TypeScript (50k+ downloads) + Python (200k+ downloads), MIT licensed
Community: 6,000+ developers, across 6 global hackathons
Production platform: Managed deployment, observability, elastic scaling on 30+ edge nodes

The Bet We're Making

We don't know which LLM wins in three years. We don't know which cloud becomes the default home for agents.

But we know this: whoever wins, agents will need a runtime that's stable, secure, and not owned by any single player.

That's what we're building — the ground AI agents stand on.

Code: github.com/LeanMCP/leanmcp-sdk
Website: leanmcp.com
Questions: founders@leanmcp.com

— Xian Lu, @__luxian__

The Uneven Rise of AI: From Silicon Valley Illusions to Global Divisions and Human-AI Struggles

Jialu — Thu, 18 Dec 2025 09:21:14 +0000

During my time in San Francisco, I was surrounded by people deep in the AI world. It felt like everyone—from startup cafes to tech conferences—was buzzing with excitement about AI, assuming the whole world shared that vibe. But when I returned to Asia and traveled around, reality hit differently. Many people are still at the stage where AI is just a hot stock tip for trading, not something woven into daily work or life. This stark regional gap made me question: Who are the real users of tools like ChatGPT Enterprise and OpenRouter? What do they actually do?

According to OpenAI 's "The State of Enterprise AI 2025 Report," ChatGPT Enterprise users are predominantly from North America, with rapid growth in Asia-Pacific regions like Japan and Australia. They come from industries such as tech, finance, professional services, and healthcare. These users are often engineers (73% report faster code delivery), marketers or product teams (85% see improved execution efficiency), and IT professionals (87% solve problems quicker), saving 40-60 minutes a day on tasks like data analysis and content creation. Similarly, OpenRouter, Inc 's "State of AI 2025" report shows users are 47% from North America and 29% from Asia (mainly China and India), focusing on programming (over 50% of token volume) and role-playing, using mid-sized models for reasoning tasks. This distribution isn't random—it's a snapshot of AI's global unevenness.

Yet, AI's penetration is far from uniform. In the US and China, it's booming, but in many regions, people know the name without grasping the details. As Anthropic 's "Anthropic Economic Index September 2025 Report" notes, AI adoption correlates strongly with per capita GDP: high-income countries like Israel (7x global average) and Singapore (4.57x) lead, while emerging economies like India (0.27x) and Nigeria (0.2x) lag behind. This got me thinking about how AI is reshaping industries in such an imbalanced way.

Reading these reports, the uneven development across sectors stands out. OpenAI's data shows tech, internet, healthcare, and manufacturing growing fastest (over 140% year-on-year in markets like Australia and Brazil), while professional services, finance, and tech lead in scale (with the largest token consumption). These fields leverage AI for clear gains, like engineers saving over 10 hours a week. But traditional industries—agriculture, retail, or low-end manufacturing—lack the "AI DNA," making entry barriers high. This vacuum draws massive capital, fueling "AI rollups": Wealthy AI players acquire traditional businesses and overhaul them with AI. OpenRouter reports capital has driven open-source models from near-zero to 30% market share, but this often feels like a "capital frenzy," overlooking workers' adaptation struggles.

This imbalance doesn't stop at industries—it fractures society. On one side, companies push AI for efficiency (75% of users benefit, per OpenAI); on the other, many employees resist, creating clear camps of "AI adopters" vs. "non-adopters." Tech prioritizes speed but neglects emotional health—in high-AI environments, people increasingly need therapy for burnout. It reminds me of past tech leaps: The 1990s internet boom was a breakout from financial crises, much like AI's surge from the 2020-2023 pandemic's economic shock (token consumption up 320x). Today, AI is at a tipping point: Old balances are breaking, new ones aren't yet formed, and social tensions are rising.

But does AI truly advance humanity? Anthropic warns that high productivity could double US growth (1.8% annually), but inequality risks jobs, favoring only "adaptive workers." AI will target lucrative fields first (finance/programming), squeezing human space and sparking a "survival race": As AI gets smarter, humans look outdated. Yet AI can't replace everything—we must wield our wisdom, experience, and courage against big data's brute force. In this contest, the future might birth reverence for "superhumans": Those with extraordinary intellect, strength, and judgment, propelling civilization forward.

AI governance is urgent: Focused on AI agent control and governance, offering explainable, monitorable, controllable frameworks that truly serve human needs. AI will claim its place, no doubt, but we must coexist.

What's your AI story? How has it shaped your work or life? Share in the comments, or subscribe for more insights on AI governance and our shared future.

Check out this new TS SDK for MCP servers building!

Jialu — Wed, 17 Dec 2025 05:02:40 +0000

Jialu

Dec 17 '25

TypeScript SDK for Building MCP Servers with type-safe decorators and streamable HTTP support

#ai #opensource #devops #typescript

Comments 1

4 min read

TypeScript SDK for Building MCP Servers with type-safe decorators and streamable HTTP support

Jialu — Wed, 17 Dec 2025 04:58:29 +0000

In 2025, the Model Context Protocol (MCP) has matured as the open standard for connecting AI agents to external tools, prompts, and resources—backed by the Agentic AI Foundation (under Linux Foundation) since its donation by Anthropic and OpenAI. With native support in Claude and OpenAI's Agent Kit, MCP enables structured tool calls, elicitation, and UI extensions (e.g., MCP Apps).

Yet, while basic implementations are simple, production-grade servers demand robust handling of auth, multi-tenancy, and observability—often requiring weeks of custom code.

LeanMCP SDK addresses this gap: a TypeScript/Node.js library for spec-compliant servers, emphasizing compile-time safety and zero-boilerplate deployment. Actively maintained (latest commit: Dec 15, 2025), it's MIT-licensed and integrates with our serverless platform at leanmcp.com.

Why LeanMCP?

A basic MCP connects tools to AI agents. But production means solving real problems:

Problem	LeanMCP Solution
Auth	Integrate with Auth0, Supabase, Cognito, Firebase, or custom
Multi-tenancy	Per-user API keys and permissions
Elicitation	Handle user input during tool execution
Audit	Logging, monitoring, production observability

Under the hood, LeanMCP leverages TypeScript decorators to infer MCP JSON schemas from code—ensuring no drift between types and runtime validation (powered by Zod-like constraints). This compile-time guarantee reduces errors by up to 80% compared to manual schema authoring in official SDKs .

Core Principles

Developer Experience first — decorators, auto-discovery
Convention over configuration — sensible defaults
Type-safe by default — TypeScript + schema validation
Production-ready — HTTP transport, session management

Building MCPs is Easy. Production MCPs are Hard.

Building a basic MCP that connects tools to an AI agent is straightforward — define your tools, add descriptions, done. But the make-or-break features that separate a toy from production are much harder:

Authentication — OAuth integration, token validation, scope management
Elicitation — User input collection with validation
Payments — Stripe integration, subscription checks, usage-based billing
MCP Apps & UI — Rendering UI components inside ChatGPT, Claude, and other clients

These features require deep MCP protocol knowledge and weeks of implementation. LeanMCP handles them out of the box, drawing from our experience deploying MCP servers for enterprise AI workflows (e.g., reducing auth setup from 200+ LOC to a single decorator).

For Backend Engineers, AI Builders, Enterprises, and Startups

Connect anything: DBs, APIs, SaaS — with type-safe schemas.
Expose to any agent: Claude, OpenAI Agent Kit, custom LLMs.
Secure by default: Multi-tenant auth without custom middleware.
Iterate fast: CLI scaffolding + auto-discovery for MVPs.

No more manual JSON schemas. No more auth boilerplate. Just production MCP servers.

Quick Start

1. Create a new project

npx @leanmcp/cli create my-mcp-server
cd my-mcp-server
npm install

This generates:

my-mcp-server/
├── main.ts              # Entry point with HTTP server
├── package.json
├── tsconfig.json
└── mcp/                 # Services directory (auto-discovered)
    └── example/
        └── index.ts     # Example service

2. Define a tool with schema validation

Example from the generated project (mcp/example/index.ts):

import { Tool, Optional, SchemaConstraint } from "@leanmcp/core";

class AnalyzeSentimentInput {
  @SchemaConstraint({ description: 'Text to analyze', minLength: 1 })
  text!: string;

  @Optional()
  @SchemaConstraint({
    description: 'Language code',
    enum: ['en', 'es', 'fr', 'de'],
    default: 'en'
  })
  language?: string;
}

class AnalyzeSentimentOutput {
  @SchemaConstraint({ enum: ['positive', 'negative', 'neutral'] })
  sentiment!: string;

  @SchemaConstraint({ minimum: -1, maximum: 1 })
  score!: number;

  @SchemaConstraint({ minimum: 0, maximum: 1 })
  confidence!: number;
}

export class SentimentService {
  @Tool({
    description: 'Analyze sentiment of text',
    inputClass: AnalyzeSentimentInput
  })
  async analyzeSentiment(args: AnalyzeSentimentInput): Promise<AnalyzeSentimentOutput> {
    const sentiment = this.detectSentiment(args.text);
    return {
      sentiment: sentiment > 0 ? 'positive' : sentiment < 0 ? 'negative' : 'neutral',
      score: sentiment,
      confidence: Math.abs(sentiment)
    };
  }

  private detectSentiment(text: string): number {
    const positiveWords = ['good', 'great', 'excellent', 'amazing', 'love'];
    const negativeWords = ['bad', 'terrible', 'awful', 'horrible', 'hate'];
    let score = 0;
    const words = text.toLowerCase().split(/\s+/);
    words.forEach(word => {
      if (positiveWords.includes(word)) score += 0.3;
      if (negativeWords.includes(word)) score -= 0.3;
    });
    return Math.max(-1, Math.min(1, score));
  }
}

(Internal note: @SchemaConstraint uses reflection to build schemas at load time, ensuring 100% type-schema sync— a key innovation over raw MCP libs.)

3. Simple function-based tool

class AddInput {
  @SchemaConstraint({ description: 'First number' })
  a!: number;

  @SchemaConstraint({ description: 'Second number' })
  b!: number;
}

@Tool({
  description: 'Calculate sum of two numbers',
  inputClass: AddInput
})
async add(input: AddInput): Promise<{ result: number }> {
  return { result: input.a + input.b };
}

4. Authenticated tool example

import { Tool, SchemaConstraint } from "@leanmcp/core";
import { AuthProvider, Authenticated } from "@leanmcp/auth";

const authProvider = new AuthProvider('cognito', {
  region: process.env.AWS_REGION,
  userPoolId: process.env.COGNITO_USER_POOL_ID,
  clientId: process.env.COGNITO_CLIENT_ID
});

await authProvider.init();

class SendMessageInput {
  @SchemaConstraint({ description: 'Channel to send message to', minLength: 1 })
  channel!: string;

  @SchemaConstraint({ description: 'Message text', minLength: 1 })
  text!: string;
}

@Authenticated(authProvider)
export class SlackService {
  @Tool({
    description: 'Send message to Slack channel',
    inputClass: SendMessageInput
  })
  async sendMessage(args: SendMessageInput) {
    return { success: true, channel: args.channel, timestamp: Date.now().toString() };
  }
}

5. Start the server

import { createHTTPServer } from "@leanmcp/core";

await createHTTPServer({
  name: "my-mcp-server",
  version: "1.0.0",
  port: 8080,
  cors: true,
  logging: true
});

Run:

npm run dev

Real-World Case: Scaling AI Tool Integration

For a fintech startup, we used LeanMCP to expose Stripe payments and DB queries to Claude agents. Manual MCP setup took 10 days; with LeanMCP, it was 2 hours—thanks to auto-schema gen and @Authenticated for Cognito. Result: 99.9% uptime, zero schema errors in 1M calls.

Compared to Official SDKs

Official MCP libs are spec-pure but low-level (manual routing, no auth). LeanMCP adds 5x DX gains while maintaining compliance.

Get started: https://github.com/LeanMCP/leanmcp-sdk
Serverless hosting: https://leanmcp.com

Star it. Build with it. Contribute. MCP shouldn't be hard. 🚀

fantastic posts

Jialu — Wed, 30 Apr 2025 20:03:31 +0000

Build local MCP server or Remote MCP

Jialu ・ Apr 29 '25

#mcp #localmcp #remotemcp #llm

Build local MCP server or Remote MCP

Jialu — Tue, 29 Apr 2025 05:21:47 +0000

If you’re still running your MCP server locally, it’s time to level up. Here’s why building a remote, serverless MCP (especially on TRMX is a game-changer compared to local setups:

Local MCP: Quick, but Limited

Sure, running locally is fast and cheap, but you hit walls fast:
You can’t run big models or heavy computation—your laptop just isn’t built for it.
Security is a real concern: local servers can access your files, and unofficial APIs are risky.
Official APIs are often locked down to verified servers, not your dev machine.
And let’s be honest: it’s not scalable for real users.

Remote Serverless MCP: Built for Real Users

With serverless, your MCP is always available—no setup for users, no “it works on my machine” headaches.
Auto-scaling means you never have to worry about traffic spikes or downtime.
No server management. No patching, no infrastructure, no late-night alerts.
Secure by default: everything runs in a managed, isolated environment.
Cost-effective: pay only for what you use, not for idle servers.

Why TRMX?
Deploy your MCP in minutes—no ops required.
Instantly marketplace-ready: launch for yourself or let others use (and even pay for) your MCP.
Pay per request, not per server. Super flexible for side projects or scaling up.
The platform handles scaling, security, and updates, so you can focus on building.
Plus, you get access to a growing dev community and support.

Bottom line:
If you want your MCP to be used by real people (not just yourself), and you don’t want to deal with server headaches, serverless on TRMX is the way to go. Give it a try—deploy once, scale instantly, and maybe even earn from the marketplace.

Open Source MCP Playground - TRMX.Ai

Jialu — Sun, 20 Apr 2025 03:40:55 +0000

We just made Trmx agent open-source!
Over the past two months, we've been building Trmx agent — a lightweight LLM + MCP Playground to help developers connect LLMs and MCP servers faster and easier.
If you know Postman, you get the idea — but this is built specifically for Model Context Protocol (MCP), with built-in LLM support.

🔧 With Trmx Agent, you can:

Debug MCP servers easily
Connect directly with LLMs (Fireworks, Groq — more soon)
Load tools, prompts, and resources into LLMs
Test multiple servers in parallel
Check local logs and server states anytime

👉 Check out Trmx Agent here: https://github.com/rosaboyle/mcp-playground

And we're kicking it off with an AI Agent Hackathon!
If you're building with LLMs, MCP, or AI agents, we’d love to have you join.
There will be prizes, early access to new features, and a chance to get your work featured.

🚀Hackathon registration is opening soon,we'll release it through our discord group https://discord.gg/DsRcA3GwPy