Settings

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

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

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

import { MCPSettings } from 'arcade-mcp-server';
 
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,
    enableErrorHandling: true,
    logLevel: 'DEBUG',
    maskErrorDetails: false,
  },
  transport: {
    sessionTimeoutSeconds: 300,
    cleanupIntervalSeconds: 10,
    maxSessions: 1000,
    maxQueueSize: 1000,
  },
  arcade: {
    apiKey: Bun.env.ARCADE_API_KEY,
    apiUrl: 'https://api.arcade.dev',
    authDisabled: false,
    environment: 'dev',
  },
  notification: {
    rateLimitPerMinute: 60,
    defaultDebounceMs: 100,
    maxQueuedNotifications: 1000,
  },
  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-server';
 
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 (session/connection management) */
  transport?: TransportSettings;
 
  /** Arcade API configuration */
  arcade?: ArcadeSettings;
 
  /** Notification settings */
  notification?: 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 (default: true) */
  enableLogging?: boolean;
 
  /** Enable error handling middleware (default: true) */
  enableErrorHandling?: boolean;
 
  /** Log level (default: 'INFO') */
  logLevel?: 'DEBUG' | 'INFO' | 'WARNING' | 'ERROR' | 'CRITICAL';
 
  /** Hide stack traces in error responses (default: false) */
  maskErrorDetails?: boolean;
}

interface TransportSettings {
  /** Session timeout in seconds (default: 300) */
  sessionTimeoutSeconds?: number;
 
  /** Cleanup interval for expired sessions in seconds (default: 10) */
  cleanupIntervalSeconds?: number;
 
  /** Maximum concurrent sessions (default: 1000) */
  maxSessions?: number;
 
  /** Maximum queue size per session (default: 1000) */
  maxQueueSize?: number;
}

interface ArcadeSettings {
  /** Arcade API key for auth and tool hosting */
  apiKey?: string;
 
  /** Arcade API URL (default: 'https://api.arcade.dev') */
  apiUrl?: string;
 
  /** Disable authentication (default: false) */
  authDisabled?: boolean;
 
  /** Server secret for worker endpoints (required to enable worker routes) */
  serverSecret?: string;
 
  /** Environment: 'dev' or 'prod' (default: 'dev') */
  environment?: 'dev' | 'prod';
 
  /** User ID for Arcade environment */
  userId?: string;
}

interface NotificationSettings {
  /** Maximum notifications per minute per client (default: 60) */
  rateLimitPerMinute?: number;
 
  /** Default debounce time in milliseconds (default: 100) */
  defaultDebounceMs?: number;
 
  /** Maximum queued notifications per client (default: 1000) */
  maxQueuedNotifications?: number;
}

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

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

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

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

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