OpenClaw

https://docs.statamcp.com
Admin
OpenClaw is a framework for developing and managing AI agents and skills, providing tools for client...
Tokens:41,148
Snippets:523
Trust Score:5
Update:4 months ago
Show doc for...
Tokens:
Raw
### Quick Setup with Environment Variables

Source: https://docs.statamcp.com/configuration

Examples of setting various environment variables for quick setup, including debug mode, working directory, monitoring, security, and logging.

```bash
# Enable debug mode
export STATA_MCP__IS_DEBUG=true

# Set working directory
export STATA_MCP__CWD="/projects/my-analysis"

# Enable monitoring with 8GB RAM limit
export STATA_MCP__IS_MONITOR=true
export STATA_MCP__RAM_LIMIT=8192

# Disable security guard (not recommended)
export STATA_MCP__IS_GUARD=false

# Enable console logging
export STATA_MCP__LOGGING_CONSOLE_HANDLER_ON=true
```

--------------------------------

### Development Setup Configuration

Source: https://docs.statamcp.com/configuration

Example TOML configuration for a development environment, enabling debug mode and console logging.

```toml
[DEBUG]
IS_DEBUG = true

[DEBUG.logging]
LOGGING_ON = true
LOGGING_CONSOLE_HANDLER_ON = true
LOGGING_FILE_HANDLER_ON = false
```

--------------------------------

### Start MCP Server with Default Settings

Source: https://docs.statamcp.com/cli

Start the MCP server for Claude Desktop using the default settings. This is the basic command to get the server running.

```bash
stata-mcp
```

--------------------------------

### Install MCP-for-Stata CLI Tool

Source: https://docs.statamcp.com/agents/openclaw

Recommended installation using uvx for direct execution, or alternatively, install globally using pip.

```bash
# Run directly with uvx (recommended)
uvx stata-mcp tool --help

# Or install and use
pip install stata-mcp
stata-mcp tool --help

```

--------------------------------

### Install stata-language-server

Source: https://docs.statamcp.com/claude-plugin

Install the stata-language-server globally using npm.

```bash
npm install -g stata-language-server
```

--------------------------------

### Install All Supported Clients

Source: https://docs.statamcp.com/clients

This command installs and configures all AI clients supported by `stata-mcp` in a single operation.

```bash
stata-mcp install --all
```

--------------------------------

### Plugin-Based MCP Server Installation

Source: https://docs.statamcp.com/claude-plugin

Install the Stata MCP plugin using a single command for simplified setup. This method includes both the MCP server and LSP server.

```bash
# Single command installation
claude plugin marketplace add sepinetam/stata-mcp
claude plugin install stata-toolbox
```

--------------------------------

### Production Setup Configuration

Source: https://docs.statamcp.com/configuration

Example TOML configuration for a production environment, disabling debug mode, enabling file logging, and configuring security and monitoring.

```toml
[DEBUG]
IS_DEBUG = false

[DEBUG.logging]
LOGGING_ON = true
LOGGING_CONSOLE_HANDLER_ON = false
LOGGING_FILE_HANDLER_ON = true
MAX_BYTES = 50_000_000
BACKUP_COUNT = 10

[SECURITY]
IS_GUARD = true

[MONITOR]
IS_MONITOR = true
MAX_RAM_MB = 16384
```

--------------------------------

### Install MCP-for-Stata to a Client using uvx

Source: https://docs.statamcp.com/cli

Install MCP-for-Stata to a specific client (e.g., cursor) using uvx. This command manages the installation process via uvx.

```bash
uvx stata-mcp install -c cursor
```

--------------------------------

### Plugin Configuration Example

Source: https://docs.statamcp.com/claude-plugin

Shows the structure of a plugin.json file, detailing plugin metadata and server configurations.

```json
{
  "name": "stata-toolbox",
  "version": "0.1.0",
  "description": "The official working package of MCP-for-Stata plugin, including mcp config and stata lsp.",
  "author": {
    "name": "Song Tan",
    "email": "sepinetam@gmail.com",
    "url": "https://www.sepinetam.com"
  },
  "homepage": "https://statamcp.com",
  "repository": "https://github.com/sepinetam/mcp-for-stata",
  "license": "AGPL-3.0",
  "keywords": ["stata", "econometrics", "empirical analysis"],
  "mcpServers": {
    ...
  },
  "lspServers": {
    ...
  }
}

```

--------------------------------

### Install psutil

Source: https://docs.statamcp.com/monitoring

Ensure the psutil library is installed and meets the minimum version requirement (>= 6.0.0) by using 'uv pip install'.

```bash
uv pip install psutil>=6.0.0
```

--------------------------------

### Add and Install Stata MCP Plugin

Source: https://docs.statamcp.com/claude-plugin

Add the Stata MCP marketplace registry and install the stata-toolbox plugin. The plugin can be installed to user, project, or local scopes.

```bash
# Add marketplace
claude plugin marketplace add sepinetam/stata-mcp

# Install plugin to user scope (default)
claude plugin install stata-toolbox

# Install to project scope (shared with team)
claude plugin install stata-toolbox --scope project

# Install to local scope (gitignored)
claude plugin install stata-toolbox --scope local
```

--------------------------------

### Check stata-language-server Installation

Source: https://docs.statamcp.com/claude-plugin

Verify if the stata-language-server is installed on your system.

```bash
# Check if stata-language-server is installed
which stata-language-server
```

--------------------------------

### Start MCP Server using uvx

Source: https://docs.statamcp.com/cli

Start the MCP server using uvx. This command is equivalent to running 'stata-mcp server' but managed by uvx.

```bash
uvx stata-mcp server
```

--------------------------------

### Verify Plugin Installation

Source: https://docs.statamcp.com/claude-plugin

List all installed plugins to verify that the Stata toolbox plugin has been successfully loaded by Claude Code.

```bash
# List installed plugins
claude plugin list
```

--------------------------------

### JSON Configuration Example

Source: https://docs.statamcp.com/clients

Example of environment variables in JSON format for Stata MCP.

```json
"env": {
  "STATA_MCP__CWD": "/path/to/project",
  "STATA_CLI": "/path/to/stata"
}

```

--------------------------------

### Basic Monitoring Setup

Source: https://docs.statamcp.com/monitoring

Enables monitoring via environment variables and runs the Stata MCP tool. No code changes are required.

```bash
export STATA_MCP__IS_MONITOR=true
export STATA_MCP__RAM_LIMIT=8192
stata-mcp    # or    stata-mcp agent run

```

--------------------------------

### Global Installation of MCP-for-Stata

Source: https://docs.statamcp.com/usage

Installs MCP-for-Stata globally on your system.

```bash
claude mcp add stata-mcp -- uvx stata-mcp

```

--------------------------------

### Install uv Package Runner

Source: https://docs.statamcp.com/claude-plugin

Install the uv package runner, recommended for managing Python packages. Installation can be done via Homebrew or the official installer script.

```bash
# Install via homebrew
brew install uv


# Or via official installer
curl -LsSf https://astral.sh/uv/install.sh | sh
```

--------------------------------

### Install Package

Source: https://docs.statamcp.com/agents/openclaw

Use the ado-install command to install enabled and approved Stata packages. The --yes flag bypasses confirmation prompts.

```bash
stata-mcp tool ado-install outreg2 --yes
```

--------------------------------

### Install MCP-for-Stata

Source: https://docs.statamcp.com/api/overview

Install the MCP-for-Stata package using pip.

```bash
pip install stata-mcp

```

--------------------------------

### Verify Installation

Source: https://docs.statamcp.com/cli

Check if stata-mcp is installed correctly by displaying its version.

```bash
stata-mcp --version

```

--------------------------------

### Verify MCP-for-Stata Installation

Source: https://docs.statamcp.com/usage

Lists installed MCP packages to verify the installation.

```bash
claude mcp list

```

--------------------------------

### Install MCP-for-Stata to AI Clients

Source: https://docs.statamcp.com/cli

Install MCP-for-Stata to supported AI clients. Use '-c' for specific clients, '--all' for all clients, or '--json-file' for custom configurations.

```bash
# Install to all supported clients (no -c, no --json-file)
stata-mcp install

# Install to a specific client
stata-mcp install -c claude-code
stata-mcp install -c cursor

# Install to all clients explicitly
stata-mcp install --all

# Install into a custom JSON config file
stata-mcp install --json-file /path/to/config.json

# Install into a nested key inside a custom JSON config file
stata-mcp install --json-file /path/to/config.json --json-index mcp.servers

```

--------------------------------

### Install Stata Package (GitHub)

Source: https://docs.statamcp.com/mcp/tools

Installs a Stata package from a GitHub repository. Requires the format 'username/reponame'. Inspect repositories before installation as they receive no security protection.

```python
ado_package_install("sepinetam/texiv", source="github")
```

--------------------------------

### RAM Limit Environment Variable Examples

Source: https://docs.statamcp.com/monitoring

Demonstrates setting the RAM limit using environment variables for no limit, 4GB, 8GB, and 16GB.

```bash
# No limit (default)
export STATA_MCP__RAM_LIMIT=-1

# 4 GB limit
export STATA_MCP__RAM_LIMIT=4096

# 8 GB limit
export STATA_MCP__RAM_LIMIT=8192

# 16 GB limit
export STATA_MCP__RAM_LIMIT=16384

```

--------------------------------

### Install stata-skill from ClawHub

Source: https://docs.statamcp.com/

Use this command to install the stata-skill from ClawHub. This is part of the OpenClaw integration.

```bash
Install `stata-skill` from ClawHub by @SepineTam. 

```

--------------------------------

### get_data_info Operational Examples

Source: https://docs.statamcp.com/mcp/tools

Demonstrates various ways to use the get_data_info tool for local files, remote data, and encoded sources.

```python
# Local file analysis
get_data_info("/data/econometrics/survey.dta")
get_data_info("~/Documents/exports/quarterly.csv", vars_list=["gdp", "inflation", "unemployment"])
```

```python
# Remote data ingestion
get_data_info("https://repository.org/datasets/panel_data.xlsx")
```

```python
# Encoded source handling
get_data_info("/data/legacy/latin1_data.csv", encoding="latin1")
```

--------------------------------

### High-Performance Computing Setup Configuration

Source: https://docs.statamcp.com/configuration

Example TOML configuration for a High-Performance Computing (HPC) environment, disabling logging and allocating a large amount of RAM for monitoring.

```toml
[DEBUG]
IS_DEBUG = false

[DEBUG.logging]
LOGGING_ON = false

[MONITOR]
IS_MONITOR = true
MAX_RAM_MB = 65536  # 64 GB
```

--------------------------------

### Quick Start: Core API Functions

Source: https://docs.statamcp.com/api/overview

Demonstrates basic usage of key MCP-for-Stata API functions for data analysis and package management.

```python
from stata_mcp.api import (
    stata_do,
    get_data_info,
    ado_package_install,
    read_log,
    stata_help,
    write_dofile,
)

# Get data information
info = get_data_info("/path/to/data.dta")

# Install an enabled and approved package
result = ado_package_install("outreg2", source="ssc")

# Execute a do-file
log = stata_do("/path/to/analysis.do")

# Read log file
content = read_log("/path/to/output.log")

```

--------------------------------

### TOML Configuration Example

Source: https://docs.statamcp.com/clients

Example of environment variables in TOML format for Stata MCP.

```toml
env = { STATA_MCP__CWD = "/path/to/project" }

```

--------------------------------

### Programmatic Monitoring Setup

Source: https://docs.statamcp.com/monitoring

Configures and executes a Stata do-file with RAM monitoring enabled using the MCP-for-Stata library.

```python
from stata_mcp.monitor import RAMMonitor
from stata_mcp.core.stata import StataDo

# Create monitor with 8GB limit
monitor = RAMMonitor(max_ram_mb=8192)

# Pass to StataDo
stata = StataDo(
    dofile_path="analysis.do",
    monitors=[monitor]  # Optional: list of monitors
)

# Execution is automatically monitored
result = stata.execute()

```

--------------------------------

### Install Client with Custom JSON Config

Source: https://docs.statamcp.com/clients

Configure a client using a custom JSON file. You can specify a nested JSON key path using `--json-index`.

```bash
stata-mcp install -c <client> --json-file /path/to/config.json
```

```bash
stata-mcp install -c <client> --json-file /path/to/config.json --json-index parent.child
```

--------------------------------

### Marketplace Manifest Example

Source: https://docs.statamcp.com/claude-plugin

Defines the marketplace.json file for registering a plugin library and its associated plugins.

```json
{
  "name": "stata-plugin-lib",
  "owner": {
    "name": "Song Tan",
    "email": "sepinetam@gmail.com"
  },
  "plugins": [
    {
      "name": "stata-toolbox',
      "source": "./plugins/stata-toolbox",
      "description": "The official working package of MCP-for-Stata plugin, including mcp config and stata lsp."
    }
  ]
}

```

--------------------------------

### Configuration File: Enable Security Guard

Source: https://docs.statamcp.com/security

This example shows how to enable the Security Guard by setting `IS_GUARD` to `true` in the `~/.statamcp/config.toml` file. This is the default and recommended setting for production environments.

```toml
[SECURITY]
IS_GUARD = true  # Default: true

```

--------------------------------

### Install Stata Packages using ado-install

Source: https://docs.statamcp.com/agents/openclaw

Installs Stata packages from various sources like SSC, GitHub, or network locations. Use '--yes' to skip confirmation.

```bash
# Install an approved SSC package
stata-mcp tool ado-install outreg2 --yes

# Install from GitHub
stata-mcp tool ado-install SepineTam/TexIV --source github --yes

# Install from network
stata-mcp tool ado-install custompkg --source net --package-source-from "https://example.com/stata/" --yes

# Don't replace existing package (useful for checking installation status)
stata-mcp tool ado-install estout --yes --is-replace false

```

--------------------------------

### Install MCP-for-Stata Skills in OpenClaw

Source: https://docs.statamcp.com/agents/openclaw

Use this command to instruct OpenClaw to install MCP-for-Stata skills from the provided URL.

```bash
Install MCP-for-Stata Skills from https://docs.statamcp.com/skills/openclaw

```

--------------------------------

### Install Stata Package (Network)

Source: https://docs.statamcp.com/mcp/tools

Installs a Stata package from a specified HTTPS URL. The URL must be a valid source for Stata packages.

```python
ado_package_install("custompkg", source="net", package_source_from="https://example.com/stata")
```

--------------------------------

### Install Specific Version of MCP-for-Stata

Source: https://docs.statamcp.com/usage

Installs a specific version of MCP-for-Stata for project-based configuration.

```bash
claude mcp add stata-mcp --env STATA_MCP__CWD=$(pwd) --scope project -- uvx --directory $(pwd) stata-mcp==1.16.3

```

--------------------------------

### Install Claude Plugin for MCP-for-Stata

Source: https://docs.statamcp.com/usage

Add the MCP-for-Stata marketplace registry and install the plugin globally or per project for Claude Code.

```bash
# Add marketplace registry
claude plugin marketplace add sepinetam/stata-mcp

# Install plugin globally
claude plugin install stata-toolbox -s user

# Install plugin per project
# claude plugin marketplace add sepinetam/stata-mcp

claude plugin install stata-toolbox@stata-plugin-lib -s project

```

--------------------------------

### Install stata-mcp Dependency

Source: https://docs.statamcp.com/claude-plugin

Install the stata-mcp Python package if it is missing.

```bash
pip install stata-mcp
```

--------------------------------

### Operational Examples for Stata Help Resource

Source: https://docs.statamcp.com/mcp/resources

Demonstrates how to use the 'help' resource to retrieve help text for various Stata commands, including regression, panel data, data management, and time series commands.

```python
# Regression commands
help("regress")
help("logit")
help("probit")

# Panel data commands
help("xtset")
help("xtreg")
help("xtmixed")

# Data management
help("merge")
help("reshape")
help("collapse")

# Time series
help("tsset")
help("arima")
help("varsoc")
```

--------------------------------

### Docker-based Installation with Sandbox

Source: https://docs.statamcp.com/cli

Install MCP-for-Stata using Docker. Requires Docker and a Stata license. Options include specifying Stata version, edition, and resource limits.

```bash
# Basic usage with default settings (StataNow 19.5 MP)
uvx stata-mcp sandbox-install -l /path/to/stata.lic

# Specify Stata version and edition
uvx stata-mcp sandbox-install \
  --version 19_5 \
  --edition mp \
  -l /path/to/stata.lic \
  -c claude

# With resource limits
uvx stata-mcp sandbox-install \
  -V 18 \
  -e se \
  -l /path/to/stata.lic \
  --cpus 2 \
  --memory 4g

```

--------------------------------

### Environment Variable Priority Example

Source: https://docs.statamcp.com/configuration

Demonstrates that environment variables take precedence over configuration file settings when both are set for the same option.

```bash
# Config file: IS_GUARD = true
# Environment variable: STATA_MCP__IS_GUARD=false
export STATA_MCP__IS_GUARD=false

# Result: Security guard is disabled (environment variable wins)
```

--------------------------------

### Install Single Client

Source: https://docs.statamcp.com/clients

Use this command to automatically configure a specific AI client for MCP servers. Replace `<client>` with the valid client key.

```bash
stata-mcp install -c <client>
```

--------------------------------

### Start MCP Server

Source: https://docs.statamcp.com/cli

Start the MCP server. By default, it uses stdio transport. You can explicitly specify other transport methods like sse or http.

```bash
# Start with stdio transport (default)
stata-mcp

```

```bash
# Explicitly specify transport method
stata-mcp -t stdio
stata-mcp -t sse
stata-mcp -t http

```

--------------------------------

### Project-based Installation of MCP-for-Stata

Source: https://docs.statamcp.com/usage

Installs MCP-for-Stata scoped to a specific research project, managing environment variables for the current working directory.

```bash
cd ~/Documents/MyResearchProject
claude mcp add stata-mcp --env STATA_MCP__CWD=$(pwd) --scope project -- uvx --directory $(pwd) stata-mcp

```

--------------------------------

### Install Stata Package

Source: https://docs.statamcp.com/api/overview

Installs a Stata package from SSC, a network URL, or GitHub. Specify the source and whether to replace an existing package.

```python
def ado_package_install(
    package: str,
    source: str = "ssc",
    is_replace: bool = False,
    package_source_from: str = None,
    config_file: str | Path | None = None,
    timeout: int = 300,
) -> str:
    ...
```

```python
# Install from SSC
result = ado_package_install("outreg2")
```

```python
# Install from GitHub
result = ado_package_install("SepineTam/TexIV", source="github")
```

```python
# Install from network
result = ado_package_install(
    "custompkg",
    source="net",
    package_source_from="https://example.com/stata",
)
```

```python
# Check installation status
result = ado_package_install("estout", is_replace=False)
```

--------------------------------

### Install Approved Ado Package

Source: https://docs.statamcp.com/cli

Install an approved ado package from SSC using the `tool ado-install` command. Use `--yes` to skip interactive confirmation.

```bash
# Install an approved ado package from SSC
stata-mcp tool ado-install reghdfe --yes

```

--------------------------------

### Install Stata LSP

Source: https://docs.statamcp.com/claude-plugin

Install the Stata Language Server using pipx. This is a prerequisite for advanced Stata editing features within Claude Code.

```bash
pipx install "git+https://github.com/euglevi/stata-language-server.git"
```

--------------------------------

### Example Validation Process

Source: https://docs.statamcp.com/security

Illustrates the step-by-step validation process, including skipping comments and checking lines against dangerous commands and patterns.

```python
code = """
* This is a comment
sysuse auto
! rm dangerous.txt  # Line 3
regress price mpg
"""

report = validator.validate(code)
# Report:
# ❌ Security validation failed. Found dangerous items:
#   - Line 3: command '!'

```

--------------------------------

### Install OpenClaw Skill

Source: https://docs.statamcp.com/skills/openclaw

Installs or updates the OpenClaw skill from a specified URL. This command creates the necessary directory and downloads the skill's main file.

```bash
mkdir -p /path/to/skill/base/stata-mcp-skill
curl -o /path/to/skill/base/stata-mcp-skill/SKILL.md https://github.com/SepineTam/mcp-for-stata/raw/refs/heads/master/docs/agents/openclaw.md
```

--------------------------------

### Install Stata Package (SSC)

Source: https://docs.statamcp.com/mcp/tools

Installs a Stata package from the SSC archive. Package names must be ASCII letters and numbers.

```python
ado_package_install("outreg2", source="ssc")
```

--------------------------------

### get_data_info Return Structure Example

Source: https://docs.statamcp.com/mcp/tools

Illustrates the expected JSON structure returned by the get_data_info tool, containing dataset metadata.

```json
{
  "overview": {"source": <path>, "obs": <int>, "var_numbers": <int>, "var_list": [<array>]},
  "info_config": {"metrics": [<array>], "max_display": <int>, "decimal_places": <int>},
  "vars_detail": {<variable_name>: {"var": <str>, "type": <str>, "summary": {...}}},
  "saved_path": <cache_file_path>
}
```

--------------------------------

### Example MCP-for-Stata Configuration File

Source: https://docs.statamcp.com/configuration

This TOML file demonstrates the structure and available settings for configuring MCP-for-Stata. It covers debugging, logging, help caching, security, project settings, and Stata-specific options.

```toml
[DEBUG]
IS_DEBUG = false

[DEBUG.logging]
LOGGING_ON = true
LOGGING_CONSOLE_HANDLER_ON = false
LOGGING_FILE_HANDLER_ON = true
LOG_FILE = "~/.statamcp/stata_mcp_debug.log"
MAX_BYTES = 10_000_000
BACKUP_COUNT = 5

[BETA]
ENABLE_WRITE_DOFILE = false

[HELP]
IS_CACHE = true
IS_SAVE = true

[SECURITY]
IS_GUARD = true
ADO_INSTALL_ALLOWED_GITHUB_REPOSITORIES = []

[PROJECT]
WORKING_DIR = ""
CLEAN_LOG_DAYS = -1
FOLDER_TAG = ".statamcp"

[MONITOR]
IS_MONITOR = false
MAX_RAM_MB = -1

[STATA]
# Optional: Override automatic Stata detection
# STATA_CLI = "/path/to/stata-mp"

[data_info]
metrics = ["obs", "mean", "stderr", "min", "max", "q1", "q3", "skewness", "kurtosis"]
string_keep_number = 10
decimal_places = 3
hash_length = 12

```

--------------------------------

### Start MCP Server with SSE Transport

Source: https://docs.statamcp.com/cli

Start the MCP server using the Server-Sent Events (SSE) transport. Use this if the default transport is not suitable.

```bash
stata-mcp -t sse
```

--------------------------------

### JSON Configuration with Security and Monitoring

Source: https://docs.statamcp.com/clients

Example of enabling security and monitoring features via JSON environment variables.

```json
"env": {
  "STATA_MCP__CWD": "/path/to/project",
  "STATA_MCP__IS_GUARD": "true",
  "STATA_MCP__IS_MONITOR": "true",
  "STATA_MCP__RAM_LIMIT": "8192"
}

```

--------------------------------

### ado_package_install()

Source: https://docs.statamcp.com/api/overview

Installs an ado package from SSC, net, or GitHub. It handles package name validation, source specification, and replacement of existing packages. The function returns an installation log or an error message.

```APIDOC
## ado_package_install()

### Description
Install an ado package from SSC, net, or GitHub.

### Method
`ado_package_install(package: str, source: str = "ssc", is_replace: bool = False, package_source_from: str = None, config_file: str | Path | None = None, timeout: int = 300) -> str`

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **package** (str) - Required - Package name or `user/repo` for GitHub
- **source** (str) - Optional - Installation source: `ssc` / `net` / `github` (Default: `"ssc"`)
- **is_replace** (bool) - Optional - Replace existing package (Default: `False`)
- **package_source_from** (str) - Optional - Validated HTTPS URL for `net` installations (Default: `None`)
- **config_file** (str | Path) - Optional - Custom config file path (Default: `None`)
- **timeout** (int) - Optional - Timeout in seconds (Default: `300`)

### Request Example
```python
# Install from SSC
result = ado_package_install("outreg2")

# Install from GitHub
result = ado_package_install("SepineTam/TexIV", source="github")

# Install from network
result = ado_package_install(
    "custompkg",
    source="net",
    package_source_from="https://example.com/stata",
)

# Check installation status
result = ado_package_install("estout", is_replace=False)
```

### Response
#### Success Response (200)
- **installation log or error message** (str)

#### Response Example
```
"Installation successful. Log details..."
```
```

--------------------------------

### TOML Configuration with All Features

Source: https://docs.statamcp.com/clients

Example of configuring Stata MCP with various features enabled in TOML format.

```toml
env.STATA_MCP__CWD = "/path/to/project"
env.STATA_MCP__IS_GUARD = "true"
env.STATA_MCP__IS_MONITOR = "true"
env.STATA_MCP__RAM_LIMIT = "8192"
env.STATA_MCP__LOGGING_CONSOLE_HANDLER_ON = "true"

```

--------------------------------

### Get Stata Command Help using 'help'

Source: https://docs.statamcp.com/agents/openclaw

Retrieves help information for Stata commands. This command is available on macOS and Linux only.

```bash
# Get command help
stata-mcp tool help regress

# Get panel data command help
stata-mcp tool help xtreg
stata-mcp tool help xtset

```

--------------------------------

### Check psutil Version

Source: https://docs.statamcp.com/monitoring

Verify the installed version of the psutil library by running a Python command that imports psutil and prints its version.

```bash
python3 -c "import psutil; print(psutil.__version__)"
```

--------------------------------

### Stata return structure example

Source: https://docs.statamcp.com/mcp/tools

Illustrates the expected dictionary structure returned by stata_do, including paths to log files and optional log content.

```json
{
  "log_file_path": {"text": "<absolute_path_to_log>", "smcl": "<absolute_path_to_smcl>"},
  "log_content": {"text": "<error_log_text_or_placeholder>", "smcl": "<smcl_path>"}
}
```

--------------------------------

### MCP Server Mode: ado_package_install Tool

Source: https://docs.statamcp.com/overview

Installs approved Stata packages. GitHub packages require an allowlist and are considered unsafe. This tool is available in the unsafe profile only.

```python
def ado_package_install(package_name: str):
    """Install approved packages; GitHub requires an allowlist."""
    # Implementation for ado_package_install tool
    pass
```

--------------------------------

### Common MCP-for-Stata Configuration

Source: https://docs.statamcp.com/

This is an example of a common configuration file (JSON) for MCP-for-Stata. It specifies the command and arguments for the stata-mcp service.

```json
{
  "mcpServers":{
    "stata-mcp": {
      "command": "uvx",
      "args": ["stata-mcp"]
    }
  }
}

```

--------------------------------

### Execute Stata do-file with default options

Source: https://docs.statamcp.com/mcp/tools

Example of executing a Stata do-file using the stata_do function with default logging and error handling.

```python
# Standard execution; log payload skipped on success
stata_do("/Users/project/stata-mcp-dofile/20250104153045.do")
```

--------------------------------

### help - Get Stata Command Help

Source: https://docs.statamcp.com/agents/openclaw

Retrieves help documentation for Stata commands. This feature is available on macOS and Linux.

```APIDOC
## help - Get Stata Command Help

### Description
Get Stata command help. (macOS and Linux only)

### Method
`stata-mcp tool help`

### Parameters
#### Path Parameters
- **stata_command** (string) - Required - Stata command name

#### Query Parameters
- **--is-read-log** (boolean) - Optional - Read output content (default: true)
- **--enable-smcl** (boolean) - Optional - Generate SMCL format output (default: true)

### Request Example
```bash
# Get command help
stata-mcp tool help regress

# Get panel data command help
stata-mcp tool help xtreg
stata-mcp tool help xtset
```
```

--------------------------------

### Execute Stata do-file with specific logging and SMCL options

Source: https://docs.statamcp.com/mcp/tools

Example of executing a Stata do-file while disabling SMCL output and preserving existing logs.

```python
# Keep prior logs and disable SMCL output
stata_do("/tmp/estimation.do",
         read_log_when_error=True,
         is_replace_log=False,
         enable_smcl=False)
```

--------------------------------

### Create a Stata do-file for regression analysis

Source: https://docs.statamcp.com/mcp/tools

Example of using write_dofile to generate a .do file that performs a regression analysis and saves the results.

```python
# Basic regression analysis
write_dofile("""
use "/data/survey.dta", clear
regress income age education experience
outreg2 using \"`output_path'/results.doc\", replace
""")
```

--------------------------------

### Get Command Help

Source: https://docs.statamcp.com/agents/openclaw

Use the help command to retrieve information about specific Stata-MCP tools or Stata commands. This command is supported on macOS and Linux.

```bash
stata-mcp tool help regress
```

--------------------------------

### Get Stata Command Documentation

Source: https://docs.statamcp.com/api/overview

Retrieves documentation for a Stata command. Supports SMCL output and cache replacement. Available on macOS and Linux only.

```python
def stata_help(
    cmd: str,
    enable_smcl: bool = True,
    config_file: str | Path | None = None,
    replace: bool = False,
) -> str:
    ...
```

```python
# Get help for a command
help_text = stata_help("regress")
print(help_text)
```

```python
# Panel data commands
help_text = stata_help("xtreg")
```

```python
# Force a fresh Stata query and overwrite caches
help_text = stata_help("xtreg", replace=True)
```

--------------------------------

### Quick Configuration with Environment Variables

Source: https://docs.statamcp.com/usage

Set various MCP-for-Stata configurations, including working directory and monitoring settings, using environment variables.

```bash
# Quick setup with environment variables
export STATA_MCP__CWD="/projects/my-analysis"
export STATA_MCP__IS_GUARD=true
export STATA_MCP__IS_MONITOR=true
export STATA_MCP__RAM_LIMIT=16384

```

--------------------------------

### Test stata-language-server

Source: https://docs.statamcp.com/claude-plugin

Test the stata-language-server by running its help command.

```bash
# Test LSP server
stata-language-server --help
```

--------------------------------

### Install Stata Package using Python API

Source: https://docs.statamcp.com/core/stata/package

Installs a specified Stata package using the Python API. This method does not require caller confirmation. Ensure installation is enabled before use.

```python
ado_package_install("estout")

```

--------------------------------

### Install Claude Code (macOS/Linux)

Source: https://docs.statamcp.com/claude-plugin

Provides the bash command to install Claude Code on macOS and Linux systems.

```bash
# macOS/Linux curl -fsSL https://claude.ai/install.sh | bash

```

--------------------------------

### Enable RAM Monitoring and Set Limit

Source: https://docs.statamcp.com/usage

Enable RAM monitoring and set a limit in MB using environment variables.

```bash
# Enable monitoring with 8GB limit
export STATA_MCP__IS_MONITOR=true
export STATA_MCP__RAM_LIMIT=8192

# Process is automatically terminated if RAM exceeds limit
result = stata_mcp.stata_do(large_analysis_code)

```

--------------------------------

### Run MCP-for-Stata CLI Commands

Source: https://docs.statamcp.com/usage

Execute various utility commands for MCP-for-Stata, such as diagnostics, package installation, data inspection, updates, and sandbox installs.

```bash
# Run diagnostics
stata-mcp doctor

# Install an enabled and approved ado package
stata-mcp tool ado-install reghdfe --yes

# Inspect a dataset
stata-mcp tool data-info /path/to/data.dta

# Update to latest version
stata-mcp update

# Docker-based sandbox install
stata-mcp sandbox-install -l /path/to/stata.lic

```

--------------------------------

### Enable Security Guard via Configuration

Source: https://docs.statamcp.com/usage

Configure the security guard system using a TOML configuration file.

```toml
# ~/.statamcp/config.toml
[SECURITY]
IS_GUARD = true  # Default: true

```

--------------------------------

### Run Do-File with Options

Source: https://docs.statamcp.com/cli

Execute a do-file using the `tool do` command. Options include reading the log only on failure (`--is-read-log true`) or setting a timeout (`--timeout`).

```bash
# Run a do-file and only read the log when execution fails
stata-mcp tool do /path/to/analysis.do --is-read-log true

```

```bash
# Stop a do-file if execution exceeds five minutes
stata-mcp tool do /path/to/analysis.do --timeout 300

```

--------------------------------

### Enable Monitoring via Configuration File

Source: https://docs.statamcp.com/monitoring

Enables the monitoring system and sets a maximum RAM limit of 8GB in the configuration file.

```toml
[MONITOR]
IS_MONITOR = true
MAX_RAM_MB = 8192  # 8 GB limit

```

--------------------------------

### Enable Security Guard via Environment Variable

Source: https://docs.statamcp.com/usage

Enable the security guard system by setting an environment variable.

```bash
export STATA_MCP__IS_GUARD=true

```

--------------------------------

### Development Workflow: Diagnostics, Install, and Data Inspection

Source: https://docs.statamcp.com/cli

A typical development workflow involving running diagnostics, installing MCP-for-Stata to a specific client (Claude Code), and inspecting a dataset.

```bash
# 1. Run diagnostics
stata-mcp doctor

# 2. Install to Claude Code
stata-mcp install -c claude-code

# 3. Inspect a dataset before writing the analysis
stata-mcp tool data-info /path/to/data.dta
```

--------------------------------

### Claude Code Global Installation CLI

Source: https://docs.statamcp.com/clients

Use the `claude mcp add` CLI for global installation of the Stata MCP client. This command sets up the necessary configuration for Claude Code.

```bash
claude mcp add stata-mcp -- uvx stata-mcp
```

--------------------------------

### MCP Server Mode: help Tool

Source: https://docs.statamcp.com/overview

Retrieves Stata command documentation from a cache. This tool is available on Unix-like systems only.

```python
def help(command_name: str):
    """Retrieve Stata command documentation (cached)."""
    # Implementation for help tool
    pass
```

--------------------------------

### Allow Third-Party Ado Installation

Source: https://docs.statamcp.com/configuration

Configure the allowed GitHub repositories for third-party ado package installations. This setting is crucial for security when executing third-party code within Stata via MCP.

```ini
[SECURITY]
ADO_INSTALL_ALLOWED_GITHUB_REPOSITORIES = ["SepineTam/TexIV"]

```

--------------------------------

### Read Stata Help

Source: https://docs.statamcp.com/cli

Access Stata help documentation through the CLI using the `tool help` command. `--enable-smcl true` can be used to format the output.

```bash
# Read Stata help through the one-shot API helper
stata-mcp tool help regress --enable-smcl true

```

--------------------------------

### ado-install - Install Stata Packages

Source: https://docs.statamcp.com/agents/openclaw

Installs Stata packages from various sources like SSC, GitHub, or network locations. It allows specifying whether to replace existing packages and can skip interactive confirmation.

```APIDOC
## ado-install - Install Stata Packages

### Description
Install ado packages from SSC, GitHub, or network sources.

### Method
`stata-mcp tool ado-install`

### Parameters
#### Path Parameters
- **package_name** (string) - Required - Package name

#### Query Parameters
- **--source** (string) - Optional - Installation source: ssc / net / github (default: ssc)
- **--package-source-from** (string) - Optional - Source URL for net installations
- **--is-replace** (boolean) - Optional - Replace existing package files (default: false)
- **-y, --yes** (boolean) - Optional - Skip the interactive installation confirmation (default: false)

### Request Example
```bash
# Install an approved SSC package
stata-mcp tool ado-install outreg2 --yes

# Install from GitHub
stata-mcp tool ado-install SepineTam/TexIV --source github --yes

# Install from network
stata-mcp tool ado-install custompkg --source net --package-source-from "https://example.com/stata/" --yes

# Don't replace existing package (useful for checking installation status)
stata-mcp tool ado-install estout --yes --is-replace false
```
```

--------------------------------

### Security Validation Example: Dangerous Command Detected

Source: https://docs.statamcp.com/security

This example illustrates the behavior when `stata_do` encounters dangerous code. The `! rm -rf /` command is detected as a security risk, causing validation to fail and returning an error.

```python
result = stata_mcp.stata_do(code="""
    sysuse auto
    ! rm -rf /  # Dangerous command
""")

# Error: Security validation failed
# ❌ Security validation failed. Found dangerous items:
#   - Line 3: command '!'

```

--------------------------------

### Create Working Directory with Write Permissions

Source: https://docs.statamcp.com/configuration

Create a new working directory and set the user's write permissions for it. This ensures MCP-for-Stata can use the specified directory.

```bash
mkdir -p /your/working/directory && chmod u+w /your/working/directory
```

--------------------------------

### Abstract MonitorBase Class

Source: https://docs.statamcp.com/monitoring

Defines the abstract base class for all monitor implementations, requiring start and stop methods.

```python
class MonitorBase(ABC):
    @abstractmethod
    def start(self, process: Any) -> None:
        """Start monitoring the given process."""
        pass

    @abstractmethod
    def stop(self) -> None:
        """Stop monitoring."""
        pass

```

--------------------------------

### Enable Claude Plugin in Settings

Source: https://docs.statamcp.com/usage

Configure Claude Code to use the installed MCP-for-Stata plugin by enabling it in the settings.json file.

```json
{
  "enabledPlugins": {
    "stata-toolbox@stata-plugin-lib": true
  }
}

```

--------------------------------

### Get Data Information

Source: https://docs.statamcp.com/api/overview

Retrieve descriptive statistics for datasets in various formats. Supports specifying variables and text encoding.

```python
def get_data_info(
    data_path: str,
    vars_list: List[str] | None = None,
    encoding: str = "utf-8",
    config_file: str | Path | None = None,
) -> str:
    ...

import json

# Get all variables
info_json = get_data_info("/project/data/survey.dta")
info = json.loads(info_json)

# Get specific variables
info_json = get_data_info(
    "/project/data/panel.csv",
    vars_list=["gdp", "inflation", "unemployment"],
    encoding="utf-8",
)

# Access the result
print(info["overview"]["obs"])  # Number of observations
print(info["vars_detail"].keys())  # Variable names

```

--------------------------------

### Claude Desktop Manual Configuration

Source: https://docs.statamcp.com/clients

Manual JSON configuration for Claude Desktop, including environment variables for working directory and Stata CLI path. Requires a client restart after edits.

```json
{
  "mcpServers": {
    "stata-mcp": {
      "command": "uvx",
      "args": ["stata-mcp"],
      "env": {
        "STATA_MCP__CWD": "/path/to/project",
        "STATA_CLI": "/Applications/Stata/StataMP"
      }
    }
  }
}
```

--------------------------------

### Enable Monitoring via Environment Variables

Source: https://docs.statamcp.com/monitoring

Enables the monitoring system and sets a RAM limit of 8192MB using environment variables.

```bash
export STATA_MCP__IS_MONITOR=true
export STATA_MCP__RAM_LIMIT=8192

```

--------------------------------

### Force Reinstall Stata Package

Source: https://docs.statamcp.com/mcp/tools

Installs or reinstalls a Stata package, forcing replacement of existing versions. Useful for updating packages.

```python
ado_package_install("estout", source="ssc", is_replace=True)
```

--------------------------------

### Check MCP-for-Stata Compatibility

Source: https://docs.statamcp.com/agents/claude_code

Run this command to verify if your system meets the requirements for MCP-for-Stata.

```bash
uvx stata-mcp doctor

```

--------------------------------

### Diagnose MCP Server Connection

Source: https://docs.statamcp.com/claude-plugin

Run these commands to test the MCP server independently, check Stata accessibility, and verify the uvx installation.

```bash
# Test MCP server independently
uvx stata-mcp doctor
```

```bash
# Check if Stata is accessible
stata-se --version
```

```bash
# Verify uvx installation
uvx --version
```

--------------------------------

### Configure All Settings via TOML File

Source: https://docs.statamcp.com/usage

Configure all MCP-for-Stata settings, including debug, security, project, and monitor options, using a TOML configuration file.

```toml
[DEBUG]
IS_DEBUG = false

[DEBUG.logging]
LOGGING_ON = true
LOGGING_CONSOLE_HANDLER_ON = false
LOGGING_FILE_HANDLER_ON = true

[SECURITY]
IS_GUARD = true

[PROJECT]
WORKING_DIR = ""

[MONITOR]
IS_MONITOR = false
MAX_RAM_MB = -1

```

--------------------------------

### Configure Stata File Extension Mapping for LSP

Source: https://docs.statamcp.com/claude-plugin

Map the .do file extension to the 'stata' language for syntax highlighting and completion in Claude Code.

```json
{
  "extensionToLanguage": {
    ".do": "stata"
  }
}
```
Tokens:
Raw