> ## Documentation Index
> Fetch the complete documentation index at: https://docs.pyleeai.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Quickstart - Use or Ship an MCP Server in Minutes

> Start fast with Pylee by either connecting to a marketplace MCP server in Cursor, or by building a working HTTP MCP server.

# Pylee Quickstart

Most teams start one of two ways:

<strong>Option A (Use a server now):</strong> Pull a trusted MCP server from the Pylee Marketplace and connect it in Cursor (or your IDE of choice). No code.

<strong>Option B (Build an HTTP MCP server):</strong> Create a minimal HTTP server, then connect it through Pylee so any agent, application, or IDE can use it. Real code, real requests.

<Info>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.</Info>

***

## 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](../../platform/pylee-marketplace) and [Registry](../../understanding-pylee/registry)

### 2) Connect in Cursor (recommended path for this quickstart)

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):**

```json theme={null}
{
  "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](../../understanding-pylee/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](../../understanding-pylee/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

```bash theme={null}
mkdir my-first-mcp-server
cd my-first-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk express 
```

### 2) Add `server.js`

```javascript theme={null}
// 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

```javascript theme={null}
{
  "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"
  }
}
```

```bash theme={null}
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](../../understanding-pylee/secrets).
* **Access control:** publish servers to **private registries** with RBAC. See [Registry](../../understanding-pylee/registry).
* **Version pinning:** pin in CI and clients to avoid surprises. See [Versions](../../understanding-pylee/versions).
* **Audit & approvals:** use Pylee’s audit trails. See [Platform Overview](../../platform/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:**
  * [Platform Overview](../../platform/platform-overview)
  * [Why Build an MCP Server?](../why-build-mcp)
  * [MCP vs API](../../architecture/mcp-vs-api)

***

## 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](../../understanding-pylee/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).

***

### Related pages

* [What is MCP?](../what-is-mcp)
* [Why Build an MCP Server?](../why-build-mcp)
* [Platform Overview](../../platform/platform-overview)
* [Pylee Marketplace](../../platform/pylee-marketplace)
* [MCP vs API](../../architecture/mcp-vs-api)