scicompute-mcp 0.1.8

MCP server for scientific computing with multiple backends

SciCompute MCP Server

MCP server for scientific computing with multiple backends. Provides AI coding assistants with mathematical computation and visualization capabilities.

Features

• Multiple computing backends (Mathematica, Octave, Python Scientific, R, SageMath)
• Image output support (plots, graphics)
• Automatic backend selection
• Persistent session state (variables persist across calls)
• Documentation query for unknown symbols
• Multi-platform support (Claude Code, Claude Desktop, OpenCode/Crush)
• Recommended: Use alongside official MATLAB MCP Server for MATLAB support

Supported Backends

Backend	Status	Capabilities
Mathematica	✅ Ready	symbolic, numeric, plot, image, audio
SageMath	✅ Ready	symbolic, numeric, plot
Python Scientific	✅ Ready	symbolic, numeric, plot
R	✅ Ready	numeric, plot
Octave	✅ Ready	numeric, plot
Julia	✅ Ready	numeric, plot
Maxima	✅ Ready	symbolic, numeric, plot

MATLAB Support

For MATLAB support, we recommend using the official MATLAB MCP Core Server from MathWorks alongside SciCompute:

Why use the official server?

• No Python version restrictions (works with any Python version)
• No library installation or patching required
• Standalone Go binary with no dependencies
• Additional features: code analysis, test running, toolbox detection

Installation:

1. Download the MATLAB MCP Core Server binary from the latest release:

   # Linux x86_64
   curl -L -o ~/matlab-mcp-core-server https://github.com/matlab/matlab-mcp-core-server/releases/latest/download/matlab-mcp-core-server-glnxa64
   chmod +x ~/matlab-mcp-core-server
   

2. Configure both servers in your MCP config:

   {
     "mcpServers": {
       "scicompute": {
         "command": "uvx",
         "args": ["scicompute-mcp"]
       },
       "matlab": {
         "command": "/home/username/matlab-mcp-core-server",
         "args": ["--matlab-root=/usr/local/MATLAB/R2024a"]
       }
     }
   }
   

See the MATLAB MCP Core Server documentation for more details.

Installation

Quick Start (Recommended)

# Install and run with uvx (auto-manages environment)
uvx scicompute-mcp

# Or install with pip
pip install scicompute-mcp
scicompute-mcp

Debian 12+ / Ubuntu 23.04+

These systems enable PEP 668 by default, which prevents direct pip installs. Use one of these methods:

# Method 1: Use --break-system-packages (quick)
pip install --break-system-packages scicompute-mcp

# Method 2: Use pipx (recommended for CLI tools)
sudo apt install -y pipx
pipx install scicompute-mcp

# Method 3: Use China mirror (faster in China)
pip install --break-system-packages -i https://pypi.tuna.tsinghua.edu.cn/simple scicompute-mcp

After installation, add ~/.local/bin to PATH if needed:

echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

Install with Optional Backends

# With Mathematica support
pip install scicompute-mcp[mathematica]

# With Octave support
pip install scicompute-mcp[octave]

# With all backends
pip install scicompute-mcp[all]

Environment Architecture

┌───────────────────────────────────────────────────────────────────────────┐
│                    MCP Server (Python 3.10+)                              │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌────────────────────┐  │
│  │ Mathematica │ │   Octave    │ │   MATLAB    │ │   py_scientific    │  │
│  │   Backend   │ │   Backend   │ │   Backend   │ │  (same Python env) │  │
│  └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ └────────────────────┘  │
│         │               │               │                                  │
│         ▼               ▼               ▼                                  │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐         │
│  │  Wolfram    │ │   octave    │ │   MATLAB    │ │      R      │  sage   │
│  │  Kernel     │ │   process   │ │   process   │ │   process   │ process │
│  └─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘         │
│         │               │               │               │         │       │
│         ▼               ▼               ▼               ▼         ▼       │
│   Independent     Independent      Independent     Independent  conda     │
│   (official)      (apt/brew)       (official)      (apt/brew)  env       │
└───────────────────────────────────────────────────────────────────────────┘

Key Points:

• MCP server only needs one Python environment
• Each backend (except py_scientific) runs as independent process, not sharing Python environment
• SageMath requires separate conda environment (Python < 3.13)

Step 1: Install Computing Backends

Install the computing backends you need (not all required):

Python Scientific Backend

Pre-installed with the main package, no additional configuration needed.

SageMath Backend

SageMath requires Python < 3.13, must be installed separately via conda:

# Configure mirror (optional, recommended for users in China)
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/

# Create SageMath environment
conda create -n sage python=3.11 -y
conda install -n sage -c conda-forge sage -y

Configure path (choose one):

# Method A: Environment variable (recommended)
export SAGE_PATH="$HOME/miniconda3/envs/sage/bin/sage"

# Method B: Modify SAGE_PATH in code
# Edit src/scicompute_mcp/backends/sage.py

R Backend

# Ubuntu/Debian
sudo apt install r-base

# macOS
brew install r

# Windows: Download from CRAN

Octave Backend

# Ubuntu/Debian
sudo apt install octave gnuplot

# macOS
brew install octave gnuplot

# Windows: Download Octave installer

Julia Backend

# Install Julia (recommended: use juliaup)
curl -fsSL https://install.julialang.org | sh

# Or download from https://julialang.org/downloads/

# Install Python package
pip install juliacall

Mathematica Backend

1. Purchase and install from Wolfram website
2. Configure path:

export MATHEMATICA_KERNEL_PATH="/usr/local/Wolfram/Wolfram/14.3/Executables/WolframKernel"

Configuration

Environment Variables

Variable	Description	Example
SAGE_PATH	SageMath path	$HOME/miniconda3/envs/sage/bin/sage
MATHEMATICA_KERNEL_PATH	WolframKernel path	/usr/local/Wolfram/Wolfram/14.3/Executables/WolframKernel
JULIA_PATH	Julia executable path	$HOME/.juliaup/bin/julia
SCICOMPUTE_PRIORITY	Backend priority	mathematica,sage,julia,py_scientific

Claude Code (.mcp.json)

{
  "mcpServers": {
    "scicompute": {
      "command": "uvx",
      "args": ["scicompute-mcp"]
    }
  }
}

Claude Desktop (claude_desktop_config.json)

{
  "mcpServers": {
    "scicompute": {
      "command": "uvx",
      "args": ["scicompute-mcp"]
    }
  }
}

OpenCode / Crush

OpenCode 1.4.6+

OpenCode 1.4.6+ reads configuration from ~/.config/opencode/opencode.json:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "scicompute": {
      "type": "local",
      "command": ["/home/username/.local/bin/scicompute-mcp"]
    }
  }
}

Important: Use absolute path to scicompute-mcp (from pip install). Avoid uvx because it downloads dependencies on first run, which may timeout.

To verify:

opencode mcp list

Using opencode mcp add (Interactive)

Alternatively, add via interactive command:

opencode mcp add
# Name: scicompute
# Type: Local
# Command: /home/username/.local/bin/scicompute-mcp

Older OpenCode versions

For older versions, use ~/.opencode.json:

{
  "mcpServers": {
    "scicompute": {
      "type": "stdio",
      "command": "/home/username/.local/bin/scicompute-mcp"
    }
  }
}

Local Development

For development or if you want to use a local installation:

{
  "mcpServers": {
    "scicompute": {
      "command": "/path/to/.venv/bin/python",
      "args": ["-m", "scicompute_mcp.server"]
    }
  }
}

Multi-Platform Support

This project supports multiple AI assistant platforms. Configuration templates are provided in the configs/ directory:

File	Platform
configs/claude-code.json	Claude Code
configs/claude-desktop.json	Claude Desktop
configs/opencode.json	OpenCode / Crush

Custom Prompts / Skills

Each platform has its own way to provide custom instructions:

Platform	Directory	Format
Claude Code	.claude/skills/*.md	Markdown
OpenCode / Crush	.opencode/commands/*.md	Markdown

Users can create custom skill files if needed.

Tools

Calling Convention

Different MCP clients have different naming conventions for calling tools:

Client	Format	Example
Claude Code	mcp__{server}__{tool}	mcp__scicompute__compute(code="1+1")
OpenCode	{server}_{tool}	scicompute_compute(code="1+1")

The examples below use the base tool names (compute, list_backends, stop). Your AI assistant will automatically use the correct format for its client.

compute(code, backend?)

Execute scientific computing code.

# Plot with Octave
compute("x = 0:0.1:10; y = sin(x); plot(x, y)", "octave")

# Symbolic computation with SageMath
compute("integrate(sin(x), x)", "sage")
compute("diff(x^3 * exp(x), x)", "sage")

# Mathematica
compute("Plot[Sin[x], {x, 0, 2 Pi}]", "mathematica")
compute("Integrate[x^2, x]", "mathematica")

# R Statistics
compute("mean(rnorm(1000))", "r")
compute("hist(rnorm(1000))", "r")

# Python Scientific
compute("sp.integrate(sp.sin(sp.Symbol('x')), sp.Symbol('x'))", "py_scientific")

# Julia
compute("plot(rand(10))", "julia")
compute("sqrt(2.0)", "julia")

# MATLAB
compute("plot(1:10, rand(1,10))", "matlab")
compute("[V,D] = eig(magic(3))", "matlab")

list_backends()

List all available backends and their capabilities.

stop(backend?)

Stop backend process and clear all state. Useful to reset variables or free memory.

stop()          # List running backends (does NOT stop any)
stop("octave")  # Stop specific backend
stop("ALL")     # Stop all running backends

Safety design: Calling stop() without arguments will NOT stop any backends. It returns a list of running backends. This prevents accidental data loss.

doc(backend?, symbol?)

Get documentation URLs for computing backends. Use this to find where to look up function documentation.

# List all backends with documentation
doc()

# Get URLs for a specific backend
doc(backend="mathematica")
doc(backend="numpy")

# Get URL for a specific function
doc(backend="mathematica", symbol="Plot3D")
doc(backend="octave", symbol="linspace")

Supported backends: mathematica, numpy, scipy, matplotlib, sympy, pandas, python, r, julia, octave, sage, maxima, matlab

Usage Examples

Ask your AI assistant:

Plot sin(x) from 0 to 2π

Calculate ∫x²dx from 0 to 1

Solve x² - 4 = 0

Look up NDSolve documentation

Getting Documentation

When you need detailed documentation for a function:

1. Use the doc tool to get documentation URLs
2. Launch a subagent with Task tool to fetch and extract documentation
3. Supported backends: Mathematica, NumPy, SciPy, Matplotlib, SymPy, Pandas, R, Julia, Octave, SageMath, Maxima, MATLAB

Example:

# Get documentation URL
doc(backend="mathematica", symbol="Plot3D")

# Then fetch the documentation
Task(
  description="Fetch Plot3D docs",
  prompt="Fetch Mathematica documentation for Plot3D from the URL returned by doc tool",
  subagent_type="general"
)

Documentation

• docs/sage.md - SageMath collaboration guide
• docs/r.md - R collaboration guide
• docs/maxima.md - Maxima collaboration guide
• docs/octave.md - Octave collaboration guide
• Use doc() tool for documentation URLs

Requirements

• Miniconda (recommended) or Python 3.10+
• For SageMath backend: conda environment with Python 3.11
• For R backend: R installation
• For Octave backend: GNU Octave + gnuplot
• For Mathematica backend: Wolfram Mathematica
• For MATLAB backend: MATLAB + MATLAB Engine for Python

License

Unlicense - Public Domain