​
Pylee Quickstart

Most teams start one of two ways: Option A (Use a server now): Pull a trusted MCP server from the Pylee Marketplace and connect it in Cursor (or your IDE of choice). No code. Option B (Build an HTTP MCP server): Create a minimal HTTP server, then connect it through Pylee so any agent, application, or IDE can use it. Real code, real requests.
Pylee is an MCP development platform with MCP server & private registr hosting, governance, and observability. You can connect servers in a client or use them programmatically from your apps via your registry. See Registry and Remotes Configuration.

​
Prerequisites

  • A Pylee account (free to start)
  • Basic familiarity with MCP concepts (skim What is MCP? if new)
  • For Option B (build): Node 18+, npm

​
Option A: Connect to an Existing Marketplace Server in Cursor (fastest)

This is the quickest way to see MCP working end-to-end with Pylee’s registry and your editor.

​
1) Pick a server in the Marketplace

Open the Marketplace in Pylee and choose a server (e.g., GitHub, Slack, a data source, or an internal server your org shares). You can add it to a private registry for your team so everyone uses the same version with the same guardrails. See: Pylee Marketplace and Registry Cursor supports MCP out of the box. You can install via one-click deep link from the Pylee UI, or configure manually. Manual setup (works everywhere): 
{
  "pylee": {
    "command": "npx",
    "args": ["-y", "@pyleeai/pylee@latest"]
  }
}
Start or reload Cursor. In the MCP tools panel, you’ll see your Pylee entry. From there, you can browse the servers you allowed in your Pylee registry and start invoking tools.
Team consistency: use a private registry so everyone new to the project gets the same curated set of MCP servers, with versions pinned and access controlled. See Registry.

​
3) Programmatic use via your Registry (optional, for apps/agents)

You don’t have to use a chat client. Your services can programmatically connect to MCP servers listed in your registry and call tools directly. See how to store and reference remote endpoints, auth, and versions in Remotes Configuration. This lets you compose servers into backend automations or multi-agent workflows, while keeping secrets and versions governed in one place.

​
Option B: Build a Working HTTP “Hello World” MCP Server

This is a minimal, real server that exposes a single tool (say_hello) over HTTP. You’ll then connect it through Pylee and use it from Cursor (or any MCP-aware client).

​
1) Create a project and install deps

mkdir my-first-mcp-server
cd my-first-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk express

​
2) Add server.js

// server.js
import express from "express";
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";

/** Build a tiny MCP server with one tool: say_hello(name, message?) */
function buildHelloWorldServer() {
  const mcp = new Server(
    { name: "hello-world-server", version: "1.0.0" },
    { capabilities: { tools: {} } },
  );

  // Advertise tools
  mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
    tools: [
      {
        name: "say_hello",
        description: "Says hello to someone",
        inputSchema: {
          type: "object",
          properties: {
            name: { type: "string", description: "Who to greet" },
            message: {
              type: "string",
              description: "Optional custom message (defaults to 'Hello')"
            }
          },
          required: ["name"]
        }
      }
    ]
  }));

  // Execute tools
  mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
    const { name, arguments: args } = req.params;
    if (name !== "say_hello") {
      throw new Error(`Unknown tool: ${name}`);
    }
    const greeting = args?.message || "Hello";
    return {
      content: [{ type: "text", text: `${greeting}, ${args.name}! 👋 Served over Streamable HTTP.` }]
    };
  });

  return mcp;
}

/** Express + Streamable HTTP transport */
const PORT = process.env.PORT ? Number(process.env.PORT) : 3000;
const app = express();
app.use(express.json());

// MCP endpoint
app.post("/mcp", async (req, res) => {
  const server = buildHelloWorldServer();
  const transport = new StreamableHTTPServerTransport({ req, res });

  // Hand control to the transport
  await server.connect(transport);
});

app.listen(PORT, () => {
  console.log(`✅ MCP server listening at http://localhost:${PORT}/mcp`);
});

​
3) Mark ES Modules and run

{
  "name": "my-first-mcp-server",
  "version": "1.0.0",
  "type": "module",
  "main": "server.js",
  "scripts": { "start": "node server.js" },
  "dependencies": {
    "@modelcontextprotocol/sdk": "^0.5.0",
    "express": "^4.18.0"
  }
}

npm start
# or
PORT=3000 node server.js
You now have a working HTTP MCP server at http://localhost:3000/mcp.

​
4) Deploy and register the server

Recommended: host on Pylee
The fastest way to make your server usable by teammates and agents is to host it directly on Pylee. One-click deploy handles HTTPS, secrets, scaling, and governance automatically. Once deployed, you can add it to a private registry and everyone on your team will see the same version in Cursor or programmatically.
  1. Go to Pylee → Create Server
  2. Choose One Click Deploy (preferred), or Remote HTTPS/SSE if you’ve already deployed elsewhere
  3. Fill in repo/entrypoint and configure secrets in the Pylee vault
  4. Deploy and Test Connection
  5. Publish it into a private registry for your team
For local iteration only: you can still run http://localhost:3000/mcp and connect directly from Cursor during dev. But the localhost URL won’t be reachable by teammates or agents. If you still want to test local, consider installing & using ngrok
Note
Need to keep it inside your network? Pylee can also be deployed behind your VPC. Contact sales for customer cloud options.

​
5) Use it via your Pylee entry

Because you added the server to Pylee and published it to a registry, any IDE or agent configured to use your Pylee entry can now discover and call say_hello.

​
Governance and security in this flow

  • Secrets & variables: store API keys and per-env config in Pylee’s encrypted vault. See Secrets.
  • Access control: publish servers to private registries with RBAC. See Registry.
  • Version pinning: pin in CI and clients to avoid surprises. See Versions.
  • Audit & approvals: use Pylee’s audit trails. See Platform Overview.

​
What should I do next?

  • If you connected a marketplace server: add it to a private registry, pin a version, and onboard a teammate.
  • If you built “Hello World”: add a second tool, deploy, and publish to your registry.
  • Explore more:

​
Quickstart FAQs (focused)

Which path should I choose first?
If you want to test connections in 2 minutes, start with Option A. If you’re building internal capabilities, do Option B. Can I use servers without a chat client?
Yes. Treat the registry as your source of truth and connect programmatically from your apps. How do teammates get the same setup?
Point them at the private registry. With version pinning and RBAC, everyone sees the same servers. What about secrets and tokens?
Store them in Secrets. Never hardcode keys. See Secrets. Can I host behind a VPC?
Yes. Deploy in your cloud and register the remote endpoint in Pylee, or run Pylee behind your VPC (contact sales).