Settings

import { MCPApp } from 'arcade-mcp';
 
const app = new MCPApp({
  name: 'my-server',
  version: '1.0.0',
  logLevel: 'DEBUG',
});

const debug = Bun.env.MCP_DEBUG === 'true';
const port = Number(Bun.env.MCP_HTTP_PORT) || 8000;

import { MCPSettings } from 'arcade-mcp';
 
// Load from environment variables
const settings = MCPSettings.fromEnv();

import { MCPSettings } from 'arcade-mcp';
 
const settings = new MCPSettings({
  debug: true,
  server: {
    name: 'My MCP Server',
    version: '1.0.0',
    title: 'My Tools',
    instructions: 'Use these tools to manage documents.',
  },
  middleware: {
    enableLogging: true,
    logLevel: 'DEBUG',
    maskErrorDetails: false,
  },
  transport: {
    type: 'http',
    httpHost: '0.0.0.0',
    httpPort: 8000,
  },
  arcade: {
    apiKey: Bun.env.ARCADE_API_KEY,
    apiUrl: 'https://api.arcade.dev',
  },
  notifications: {
    enabled: true,
  },
  toolEnvironment: {
    // Additional secrets available to tools
    DATABASE_URL: Bun.env.DATABASE_URL,
    REDIS_URL: Bun.env.REDIS_URL,
  },
});

import { MCPServer, MCPSettings, ToolCatalog } from 'arcade-mcp';
 
const settings = MCPSettings.fromEnv();
 
const server = new MCPServer({
  catalog: new ToolCatalog(),
  settings,
});

const settings = MCPSettings.fromEnv();
 
// Get all secrets available to tools
const secrets = settings.toolSecrets();
// => { DATABASE_URL: '...', REDIS_URL: '...', ... }

interface MCPSettings {
  /** Enable debug mode (verbose logging, stack traces) */
  debug?: boolean;
 
  /** Server configuration */
  server?: ServerSettings;
 
  /** Middleware configuration */
  middleware?: MiddlewareSettings;
 
  /** Transport configuration */
  transport?: TransportSettings;
 
  /** Arcade API configuration */
  arcade?: ArcadeSettings;
 
  /** Notification settings */
  notifications?: NotificationSettings;
 
  /** Tool environment / secrets */
  toolEnvironment?: ToolEnvironmentSettings;
}

interface ServerSettings {
  /** Server name shown to AI clients */
  name: string;
 
  /** Server version */
  version: string;
 
  /** Human-readable title */
  title?: string;
 
  /** Usage instructions for AI clients */
  instructions?: string;
}

interface MiddlewareSettings {
  /** Enable request logging */
  enableLogging: boolean;
 
  /** Log level */
  logLevel: 'DEBUG' | 'INFO' | 'WARNING' | 'ERROR';
 
  /** Hide stack traces in error responses (always true in production) */
  maskErrorDetails: boolean;
}

interface TransportSettings {
  /** Transport type */
  type: 'stdio' | 'http';
 
  /** HTTP host (only for http transport) */
  httpHost: string;
 
  /** HTTP port (only for http transport) */
  httpPort: number;
}

interface ArcadeSettings {
  /** Arcade API key for auth and tool hosting */
  apiKey?: string;
 
  /** Arcade API URL (defaults to production) */
  apiUrl?: string;
}

interface NotificationSettings {
  /** Enable notifications to clients */
  enabled: boolean;
 
  /** Notification timeout in milliseconds */
  timeoutMs?: number;
}

interface ToolEnvironmentSettings {
  /** Key-value pairs of secrets */
  [key: string]: string | undefined;
}

import { MCPApp } from 'arcade-mcp';
 
const isDev = Bun.env.NODE_ENV !== 'production';
 
const app = new MCPApp({
  name: 'my-server',
  logLevel: isDev ? 'DEBUG' : 'INFO',
  // In development, show full error details
  // ErrorHandlingMiddleware reads this internally
});
 
app.run({
  host: isDev ? '127.0.0.1' : '0.0.0.0',
  port: Number(Bun.env.PORT) || 8000,
  reload: isDev,
});

import { MCPSettings } from 'arcade-mcp';
 
// Load from JSON file
const configFile = Bun.file('./config.json');
const config = await configFile.json();
 
const settings = new MCPSettings(config);

import { MCPSettings, MCPServer, ToolCatalog } from 'arcade-mcp';
 
// Shared settings across multiple servers
const baseSettings = MCPSettings.fromEnv();
 
const serverA = new MCPServer({
  catalog: catalogA,
  settings: baseSettings,
  name: 'server-a',
});
 
const serverB = new MCPServer({
  catalog: catalogB,
  settings: baseSettings,
  name: 'server-b',
});

import { MCPApp, FatalToolError } from 'arcade-mcp';
 
const requiredEnvVars = ['ARCADE_API_KEY', 'DATABASE_URL'];
 
for (const envVar of requiredEnvVars) {
  if (!Bun.env[envVar]) {
    throw new FatalToolError(`Missing required environment variable: ${envVar}`);
  }
}
 
const app = new MCPApp({ name: 'my-server' });

import type { MCPAppOptions } from 'arcade-mcp';
 
const config = {
  name: 'my-server',
  version: '1.0.0',
  logLevel: 'DEBUG',
} satisfies MCPAppOptions;
 
const app = new MCPApp(config);