MCP Module - API Reference

Exports from `indusagi/mcp`

Classes

MCPClient

class MCPClient {
  constructor(options: MCPClientOptions);
  connect(): Promise<void>;
  disconnect(): Promise<void>;
  listTools(): Promise<MCPToolDefinition[]>;
  callTool(name: string, params: any): Promise<any>;
  listResources(): Promise<MCPResource[]>;
  readResource(uri: string): Promise<string>;
  listPrompts(): Promise<MCPPrompt[]>;
  getPrompt(name: string, params?: Record<string, string>): Promise<string>;
  get serverName(): string;
  get isConnected(): boolean;
}

MCPClientPool

class MCPClientPool {
  constructor(options: MCPClientPoolOptions);
  connectAll(): Promise<void>;
  disconnectAll(): Promise<void>;
  addServer(config: MCPConnectionOptions): Promise<void>;
  removeServer(name: string): Promise<void>;
  getAllClients(): MCPClient[];
  getClient(name: string): MCPClient | undefined;
  getStatus(): MCPServerStatus[];
}

MCPServer

class MCPServer {
  constructor(options: MCPServerOptions);
  addTool(tool: ToolDefinition): void;
  addResource(resource: ResourceDefinition): void;
  addPrompt(prompt: PromptDefinition): void;
  startStdio(): Promise<void>;
  close(): Promise<void>;
}

Functions

initializeMCP

async function initializeMCP(
  registry: ToolRegistry,
  cwd: string
): Promise<{ pool: MCPClientPool; toolCount: number }>;

registerMCPToolsInRegistry

async function registerMCPToolsInRegistry(
  registry: ToolRegistry,
  client: MCPClient,
  tools: MCPToolDefinition[]
): Promise<number>;

createMCPToolsMap

function createMCPToolsMap(
  client: MCPClient,
  tools: MCPToolDefinition[]
): Record<string, AgentTool>;

createMCPAgentToolFactory

function createMCPAgentToolFactory(
  tool: MCPToolDefinition,
  client: MCPClient
): () => AgentTool;

loadMCPConfig

function loadMCPConfig(cwd?: string): MCPConnectionOptions[];

saveConfig

async function saveConfig(
  config: MCPServerConfigEntry,
  options?: { scope: "user" | "project" }
): Promise<void>;

getUserConfigPath

function getUserConfigPath(): string;

getProjectConfigPath

function getProjectConfigPath(): string;

jsonSchemaToTypeBox

function jsonSchemaToTypeBox(schema: any): any;

Error Classes

MCPError

class MCPError extends Error {
  code: MCPErrorCode;
  constructor(message: string, code: MCPErrorCode);
}

Error Codes

enum MCPErrorCode {
  CONNECTION_FAILED = "CONNECTION_FAILED",
  TIMEOUT = "TIMEOUT",
  TOOL_NOT_FOUND = "TOOL_NOT_FOUND",
  INVALID_PARAMETERS = "INVALID_PARAMETERS",
  EXECUTION_ERROR = "EXECUTION_ERROR",
  SERVER_ERROR = "SERVER_ERROR",
  NOT_CONNECTED = "NOT_CONNECTED",
  CONFIG_ERROR = "CONFIG_ERROR",
  SCHEMA_CONVERSION_ERROR = "SCHEMA_CONVERSION_ERROR",
}

Type Definitions

MCPClientOptions

interface MCPClientOptions {
  name: string;
  config: MCPServerConfig;
  timeout?: number;
  logger?: (msg: MCPLogMessage) => void;
  enableServerLogs?: boolean;
}

MCPClientPoolOptions

interface MCPClientPoolOptions {
  servers: MCPConnectionOptions[];
}

MCPConnectionOptions

interface MCPConnectionOptions {
  name: string;
  config: MCPServerConfig;
  env?: Record<string, string>;
  timeout?: number;
}

MCPServerConfig

type MCPServerConfig = StdioServerConfig | HttpServerConfig;

interface StdioServerConfig {
  command: string;
  args?: string[];
  env?: Record<string, string>;
}

interface HttpServerConfig {
  url: string;
  headers?: Record<string, string>;
}

MCPToolDefinition

interface MCPToolDefinition {
  name: string;
  description: string;
  inputSchema: Record<string, any>;
}

MCPResource

interface MCPResource {
  uri: string;
  name: string;
  description?: string;
  mimeType?: string;
}

MCPPrompt

interface MCPPrompt {
  name: string;
  description?: string;
  arguments?: Array<{
    name: string;
    description?: string;
    required?: boolean;
  }>;
}

MCPServerStatus

interface MCPServerStatus {
  name: string;
  connected: boolean;
  toolCount?: number;
  resourceCount?: number;
  promptCount?: number;
}

Configuration File Format

~/.indusagi/mcp.json (or .mcp.json)

{
  "servers": [
    {
      "name": "filesystem",
      "config": {
        "command": "npx",
        "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
      }
    },
    {
      "name": "github",
      "config": {
        "command": "npx",
        "args": ["-y", "@modelcontextprotocol/server-github"]
      },
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  ]
}

Environment Variables

• MCP_CONFIG_PATH - Custom config directory path
• INDUSAGI_DEBUG - Enable debug logging (set to "1")
• Provider-specific: GITHUB_TOKEN, BRAVE_API_KEY, etc.

Usage Patterns

Basic Connection

const client = new MCPClient({
  name: "filesystem",
  config: { command: "npx", args: ["-y", "@modelcontextprotocol/server-filesystem", "."] },
});
await client.connect();

Pool Management

const pool = new MCPClientPool({
  servers: loadMCPConfig(process.cwd()),
});
await pool.connectAll();

Tool Registration

const registry = new ToolRegistry();
const { pool, toolCount } = await initializeMCP(registry);

For complete examples and advanced usage, see developer-guide.txt and integration.txt.