import { MCPServer } from "mcpfy-sdk/server";

import {
  MCPServer,
  jwksVerifier,
  text,
  markdown,
  image,
  object,
  error,
} from "mcpfy-sdk/server";

import { MCPServer } from "mcpfy-sdk/server";

const server = new MCPServer({
  name: "my-server",
  version: "1.0.0",
});

server.nativeServer

interface MCPServerConfig {
  name: string;
  version: string;
  description?: string;
  basePath?: string;
  icon?: string | ServerIcon;
  auth?: AuthConfig;
  widgetsDir?: string;
}

const server = new MCPServer({
  name: "weather-server",
  version: "1.0.0",
  description: "Provides weather-related MCP tools.",
  basePath: "/weather",
  widgetsDir: "src/widgets",
});

server.tool()

server.tool({
  name: "hello",
  description: "Say hello",
}, async () => {
  return {
    content: [
      {
        type: "text",
        text: "Hello!",
      },
    ],
  };
});

server.prompt()

server.prompt({
  name: "code-review",
  description: "Review a piece of code",
}, async (params) => {
  // Return prompt messages
});

server.resource()

server.resource({
  name: "config",
  uri: "config://app",
}, async () => {
  // Return resource contents
});

server.resourceTemplate()

server.widget()

server.tool({
  name: "weather",
  widget: "weather",
});

await server.listen();

await server.listen();

await server.listen({
  transport: "stdio",
});

await server.listen({
  transport: "http",
});

3000

localhost

await server.listen({
  transport: "http",
});

http://localhost:3000/mcp

interface ListenOptions {
  transport?: "stdio" | "http";
  port?: number;
  host?: string;
  silent?: boolean;
}

transport: "stdio"

transport: "http"

"stdio"

await server.listen({
  transport: "http",
  port: 4000,
});

http://localhost:4000/mcp

await server.listen({
  transport: "http",
  port: 0,
});

await server.listen({
  transport: "http",
  host: "0.0.0.0",
});

localhost

await server.listen({
  transport: "http",
  silent: true,
});

false

1. listen({ port })
2. --port N / --port=N
3. process.env.PORT
4. 3000

await server.listen({
  transport: "http",
  port: 4000,
});

node server.js --port 5000

node server.js --port=5000

parsePortFromArgv()

import { parsePortFromArgv } from "mcpfy-sdk/server";

const port = parsePortFromArgv();

--port 4000

--port=4000

number | undefined

process.env.PORT

$env:PORT = "8080"

await server.listen({
  transport: "http",
});

interface ListenResult {
  transport: "stdio" | "http";
  port?: number;
  host?: string;
  url?: string;
}

const result = await server.listen({
  transport: "stdio",
});

{
  transport: "stdio"
}

const result = await server.listen({
  transport: "http",
  port: 4000,
});

{
  transport: "http",
  port: 4000,
  host: "localhost",
  url: "http://localhost:4000/mcp"
}

/mcp

const server = new MCPServer({
  name: "weather-server",
  version: "1.0.0",
  basePath: "/weather",
});

await server.listen({
  transport: "http",
  port: 3000,
});

http://localhost:3000/weather

const server = new MCPServer({
  name: "my-server",
  version: "1.0.0",
  icon: "./icon.png",
});

const server = new MCPServer({
  name: "secure-server",
  version: "1.0.0",
  auth: authConfig,
});

await server.listen({
  transport: "http",
  port: 3000,
});

import { jwksVerifier } from "mcpfy-sdk/server";

server.nativeServer

const nativeServer = server.nativeServer;

await server.refreshResource("config://app");

await server.refreshResource("data://users");

server.refreshResources();

server.refreshTools();

server.refreshPrompts();

server.mountRemote()

await server.mountRemote({
  weather: {
    // remote server configuration
  },
});

weather__get_forecast

get_forecast

weather

await server.close();

await server.listen({
  transport: "http",
  port: 3000,
});

// ... server is running

await server.close();

server.http

await server.listen({
  transport: "http",
  port: 3000,
});

console.log(server.http);

import { MCPServer, text } from "mcpfy-sdk/server";

const server = new MCPServer({
  name: "example-server",
  version: "1.0.0",
  description: "Example MCP server",
  basePath: "/mcp",
});

server.tool(
  {
    name: "hello",
    description: "Returns a greeting",
  },
  async () => {
    return text("Hello from mcpfy!");
  }
);

const result = await server.listen({
  transport: "http",
  port: 3000,
});

console.log(`MCP server running at ${result.url}`);

http://localhost:3000/mcp

import { MCPServer, text } from "mcpfy-sdk/server";

const server = new MCPServer({
  name: "stdio-server",
  version: "1.0.0",
});

server.tool(
  {
    name: "hello",
    description: "Returns a greeting",
  },
  async () => {
    return text("Hello from the MCP server!");
  }
);

await server.listen();

await server.listen();

my-mcp-server/
├── src/
│   ├── index.ts
│   ├── tools/
│   │   ├── weather.ts
│   │   └── search.ts
│   ├── prompts/
│   │   └── assistant.ts
│   ├── resources/
│   │   └── documentation.ts
│   └── widgets/
│       └── weather/
├── package.json
└── tsconfig.json

MCPServer
parsePortFromArgv

MCPServerConfig
ListenOptions
ListenResult
ServerIcon
HttpHandle

ToolDefinition
ToolCallback

PromptDefinition
PromptCallback

ResourceDefinition
ReadResourceCallback
FlatResourceTemplateDefinition
ReadResourceTemplateCallback

ToolContext
SampleOptions
LogLevel
AskUrlOptions

text
markdown
image
object
error

UIResourceDefinition
WidgetCallback
WidgetContent
WidgetCsp
WidgetOptions
WidgetProtocol
DEFAULT_WIDGETS_DIR

AuthConfig
AuthInfo
jwksVerifier
JwksVerifierOptions
oauthAuth0Provider
oauthWorkOSProvider

RemoteServerConfig

import { MCPServer } from "mcpfy-sdk/server";

const server = new MCPServer({
  name: "my-mcp-server",
  version: "1.0.0",
});

// Register tools, prompts, resources, and widgets.

await server.listen({
  transport: "http",
  port: 3000,
});

await server.listen({
  transport: "stdio",
});

await server.listen({
  transport: "http",
  port: 3000,
});