pyodide_install-packages

Install Python packages in Pyodide environments for LLM-driven Python execution. Specify multiple packages using space-separated names.

Instructions

Install Python packages using Pyodide. Multiple packages can be specified using space-separated format.

Input Schema

TableJSON Schema

Name	Required	Description	Default
`package`	Yes	Python package(s) to install. For multiple packages, use space-separated format (e.g., 'numpy matplotlib pandas').

Implementation Reference

src/handlers/index.ts:96-104 (handler)

Handler logic for pyodide_install-packages: validates arguments using arktype and delegates to PyodideManager.installPackage

case "pyodide_install-packages": {
  const installPythonPackagesArgs = isInstallPythonPackagesArgs(args);
  if (installPythonPackagesArgs instanceof type.errors) {
    throw installPythonPackagesArgs;
  }
  const { package: packageName } = installPythonPackagesArgs;
  const results = await pyodideManager.installPackage(packageName);
  return results;
}

src/tools/index.ts:23-38 (schema)

Tool schema defining name, description, and input schema for pyodide_install-packages

export const INSTALL_PYTHON_PACKAGES_TOOL: Tool = {
  name: "pyodide_install-packages",
  description:
    "Install Python packages using Pyodide. Multiple packages can be specified using space-separated format.",
  inputSchema: {
    type: "object",
    properties: {
      package: {
        type: "string",
        description:
          "Python package(s) to install. For multiple packages, use space-separated format (e.g., 'numpy matplotlib pandas').",
      },
    },
    required: ["package"],
  },
};

src/handlers/index.ts:32-38 (registration)

Registration of the pyodide_install-packages tool in the TOOLS array used for listTools

const TOOLS: Tool[] = [
  tools.EXECUTE_PYTHON_TOOL,
  tools.INSTALL_PYTHON_PACKAGES_TOOL,
  tools.GET_MOUNT_POINTS_TOOL,
  tools.LIST_MOUNTED_DIRECTORY_TOOL,
  tools.READ_IMAGE_TOOL,
];

src/lib/pyodide/pyodide-manager.ts:396-518 (helper)

Core implementation of package installation: tries loadPackage first, falls back to micropip with wheel download for unsupported packages

async installPackage(packageName: string) {
  if (!this.pyodide) {
    return formatCallToolError("Pyodide not initialized");
  }

  try {
    // パッケージ名をスペースで分割
    const packages = packageName
      .split(" ")
      .map((pkg) => pkg.trim())
      .filter(Boolean);

    if (packages.length === 0) {
      return formatCallToolError("No valid package names specified");
    }

    // 出力メッセージを集める
    const outputs: string[] = [];

    // 各パッケージを処理
    for (const pkg of packages) {
      try {
        // 1. まずpyodide.loadPackageでインストールを試みる
        outputs.push(`Attempting to install ${pkg} using loadPackage...`);

        try {
          await this.pyodide.loadPackage(pkg, {
            messageCallback: (msg) => {
              outputs.push(`loadPackage: ${msg}`);
            },
            errorCallback: (err) => {
              throw new Error(err);
            },
          });
          outputs.push(`Successfully installed ${pkg} using loadPackage.`);
          continue; // このパッケージは成功したので次のパッケージへ
        } catch (loadPackageError) {
          outputs.push(
            `loadPackage failed for ${pkg}: ${
              loadPackageError instanceof Error
                ? loadPackageError.message
                : String(loadPackageError)
            }`
          );
          outputs.push(`Falling back to micropip for ${pkg}...`);

          // loadPackageが失敗した場合は、micropipを使用する
          // micropipがまだロードされていない場合はロードする
          try {
            // micropipをロードする
            await this.pyodide.loadPackage("micropip", {
              messageCallback: (msg) => {
                outputs.push(`loadPackage: ${msg}`);
              },
              errorCallback: (err) => {
                throw new Error(err);
              },
            });
          } catch (micropipLoadError) {
            throw new Error(
              `Failed to load micropip: ${
                micropipLoadError instanceof Error
                  ? micropipLoadError.message
                  : String(micropipLoadError)
              }`
            );
          }

          // 2. micropipを使ったインストール処理
          // 一時ディレクトリを作成
          const tempDir = process.env.PYODIDE_CACHE_DIR || "./cache";
          if (!fs.existsSync(tempDir)) {
            fs.mkdirSync(tempDir, { recursive: true });
          }

          // Pyodide内のtempディレクトリを作成
          this.pyodide.FS.mkdirTree("/tmp/wheels");

          // PyPIからwheelのURLを取得
          const wheelUrl = await getWheelUrl(pkg);
          const wheelFilename = path.basename(wheelUrl);
          const localWheelPath = path.join(tempDir, wheelFilename);

          // wheelをダウンロード
          outputs.push(`Downloading wheel for ${pkg}...`);
          await downloadWheel(wheelUrl, localWheelPath);

          // wheelをPyodideのファイルシステムにコピー
          const wheelData = fs.readFileSync(localWheelPath);
          const pyodideWheelPath = `/tmp/wheels/${wheelFilename}`;
          this.pyodide.FS.writeFile(pyodideWheelPath, wheelData);

          // micropipでインストール
          const { output } = await withOutputCapture(
            this.pyodide,
            async () => {
              await this.pyodide!.runPythonAsync(`
                import micropip
                await micropip.install("emfs:${pyodideWheelPath}")
              `);
            },
            { suppressConsole: true }
          );

          outputs.push(
            `Successfully installed ${pkg} using micropip: ${output}`
          );
        }
      } catch (error) {
        // 個別のパッケージのエラーを記録して続行
        outputs.push(
          `Failed to install ${pkg}: ${
            error instanceof Error ? error.message : String(error)
          }`
        );
      }
    }

    return formatCallToolSuccess(outputs.join("\n\n"));
  } catch (error) {
    return formatCallToolError(error);
  }
}

mcp-pyodide