FastMCP 3.0 TypeScript SDK: Building Enterprise Model Context Protocol Servers for Cursor IDE

Introduction to FastMCP 3.0 and the Model Context Protocol

As the AI development landscape evolves rapidly, the demand for scalable, robust, and secure ways to provide context to Large Language Models (LLMs) has skyrocketed. The Model Context Protocol (MCP) has emerged as the industry standard for this task. With the release of the FastMCP 3.0 TypeScript SDK, developers now have an enterprise-grade toolkit for building high-performance MCP servers specifically tailored for advanced environments like the Cursor IDE. This guide will take you through everything you need to know to build, configure, and secure your own FastMCP server.

Before diving into the code, it's highly recommended to explore other tools in our MCP Tools Directory to see what the community is building and gain inspiration for your own implementations.

Why Choose FastMCP 3.0?

FastMCP 3.0 isn't just an incremental update; it represents a paradigm shift in how we build context servers. It brings several enterprise-ready features to the table:

• TypeScript First: Enjoy first-class type safety, autocomplete, and compile-time error checking.
• High Performance: Optimized event loops and reduced memory footprint make it suitable for high-throughput environments.
• OAuth 2.0 Support: Built-in primitives for handling secure authentication and authorization flows natively.
• Cursor IDE Integration: Seamless compatibility with Cursor, enabling your AI assistant to read your custom context sources in real-time.

Project Setup and Installation

Let's start by setting up our TypeScript project. Open your terminal and run the following commands to initialize the project and install the necessary dependencies.

mkdir fastmcp-enterprise-server
cd fastmcp-enterprise-server
npm init -y
npm install @modelcontextprotocol/sdk fastmcp dotenv zod
npm install -D typescript @types/node tsx

Next, initialize your TypeScript configuration:

npx tsc --init

Ensure your tsconfig.json has "strict": true and targets ES2022 or later for the best compatibility with FastMCP.

Building the Server: Full TypeScript Server Code

The core of our MCP server will be defined in a single file for simplicity, though in an enterprise scenario, you would structure this across multiple modules. Here is the complete TypeScript server code utilizing FastMCP 3.0.

import { FastMCP } from "fastmcp";
import { z } from "zod";
import dotenv from "dotenv";

dotenv.config();

// Initialize the FastMCP server with OAuth 2.0 configurations
const server = new FastMCP({
  name: "Enterprise-Cursor-MCP",
  version: "1.0.0",
  auth: {
    type: "oauth2",
    clientId: process.env.OAUTH_CLIENT_ID,
    clientSecret: process.env.OAUTH_CLIENT_SECRET,
    authUrl: "https://your-auth-provider.com/oauth/authorize",
    tokenUrl: "https://your-auth-provider.com/oauth/token"
  }
});

// Define a robust tool for fetching proprietary business metrics
server.addTool({
  name: "get_business_metrics",
  description: "Retrieves real-time business metrics for a given department.",
  parameters: z.object({
    department: z.enum(["sales", "engineering", "marketing"]),
    timeframe: z.enum(["daily", "weekly", "monthly"]),
    includeProjections: z.boolean().optional().default(false)
  }),
  execute: async (args, context) => {
    // In a real application, ensure the context contains a valid OAuth token
    if (!context.token) {
      throw new Error("Unauthorized: Missing OAuth token");
    }

    console.log(`Fetching ${args.timeframe} metrics for ${args.department}`);
    
    // Mock data retrieval
    const data = {
      department: args.department,
      metrics: {
        revenue: 1500000,
        growth: "15%",
        activeProjects: 42
      }
    };

    return {
      content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
    };
  }
});

// Start the server using stdio transport (standard for Cursor)
server.start().then(() => {
  console.error("Enterprise FastMCP Server running on stdio");
}).catch((error) => {
  console.error("Fatal error starting server:", error);
  process.exit(1);
});

Defining Tool Input Schemas (JSON)

Under the hood, FastMCP translates your Zod definitions into standard JSON Schema format which the Model Context Protocol requires. If you were to define this manually or inspect the server's capabilities endpoint, the inputSchema JSON definition would look like this:

{
  "type": "object",
  "properties": {
    "department": {
      "type": "string",
      "enum": ["sales", "engineering", "marketing"]
    },
    "timeframe": {
      "type": "string",
      "enum": ["daily", "weekly", "monthly"]
    },
    "includeProjections": {
      "type": "boolean",
      "default": false
    }
  },
  "required": ["department", "timeframe"]
}

This rigorous schema definition ensures that the LLM driving Cursor knows exactly what parameters to provide, reducing hallucinations and improving tool execution reliability.

Integrating with Cursor IDE: ~/.cursor/mcp.json Config Block

To connect your newly built FastMCP server to your Cursor IDE, you must update your Cursor configuration. Cursor looks for MCP configurations in the ~/.cursor/mcp.json file.

Open or create this file and add the following configuration block. Make sure to replace the placeholder paths with the actual absolute path to your project.

{
  "mcpServers": {
    "enterprise-metrics": {
      "command": "npx",
      "args": [
        "tsx",
        "/absolute/path/to/fastmcp-enterprise-server/index.ts"
      ],
      "env": {
        "OAUTH_CLIENT_ID": "your-secure-client-id",
        "OAUTH_CLIENT_SECRET": "your-secure-client-secret"
      }
    }
  }
}

Once saved, restart your Cursor IDE or reload the window to initialize the server connection. Cursor's AI features will now have access to your custom get_business_metrics tool.

Enterprise Security Guide

When deploying MCP servers that access sensitive enterprise data, security is paramount. Here is a comprehensive security guide for your FastMCP deployments:

1. Implement Robust OAuth 2.0 Flows

Never hardcode credentials or rely on static API keys for enterprise systems. FastMCP 3.0's native OAuth 2.0 support allows you to securely authenticate the user interacting with the IDE. Ensure that your authorization server issues short-lived access tokens and utilizes refresh tokens securely.

2. Strict Input Validation

LLMs can sometimes generate unexpected inputs. By leveraging Zod schemas (as shown in our code), you guarantee that the input exactly matches your expected format before it ever reaches your business logic. Do not bypass this validation step.

3. Rate Limiting and Quotas

Because automated AI agents can issue requests rapidly in a loop, it is crucial to implement rate limiting on your MCP server. FastMCP allows middleware injection where you can implement IP or Token-based rate limiting to prevent Denial of Service (DoS) attacks on your backend infrastructure.

4. Principle of Least Privilege

Ensure the OAuth scopes requested by your MCP server are narrowly defined. If the tool only needs to read sales data, do not request write permissions or access to HR systems. The narrower the scope, the smaller the blast radius in case of a compromise.

Expanding Your Capabilities

Building a robust MCP server is just the beginning. To truly leverage the power of agentic AI within your organization, you should explore how these servers tie into broader automated systems. Check out our comprehensive guides on building AI Workflows that orchestrate multiple MCP tools across various platforms.

Answer Engine Optimization (AEO) Q&A

Q: How does FastMCP 3.0 handle authentication for enterprise data?
A: FastMCP 3.0 includes native support for OAuth 2.0. By configuring the server with your Identity Provider's endpoints and client credentials, FastMCP manages the token exchange and validation, ensuring that all tool executions are authenticated against your enterprise security policies.

Q: Can I use FastMCP 3.0 with IDEs other than Cursor?
A: Yes. FastMCP 3.0 implements the standard Model Context Protocol. While it integrates seamlessly with Cursor via the mcp.json configuration, it is fully compatible with any client that speaks the standard MCP stdio or HTTP/SSE protocols, such as Claude Desktop or Windsurf.

Q: Why should I use Zod for inputSchemas in FastMCP instead of writing raw JSON?
A: Using Zod in TypeScript provides dual benefits: it generates the required JSON schema for the LLM at runtime, and it provides strict TypeScript types and runtime validation for your execute functions. This drastically reduces bugs caused by malformed LLM outputs and improves overall server reliability.

Conclusion

The FastMCP 3.0 TypeScript SDK is a powerful enabler for developers looking to bridge the gap between their enterprise data silos and advanced AI coding assistants like Cursor. By following this guide, implementing secure OAuth, writing strict schemas, and configuring your IDE correctly, you've taken a significant step toward hyper-productive, AI-augmented development.