LLM 沙盒

轻松安全地执行 LLM 生成的代码

LLM 沙盒 是一种轻量级且可移植的沙盒环境，专为在安全、隔离的模式下运行大型语言模型（LLM）生成的代码而设计。它为 AI 生成的代码提供了一个安全的执行环境，同时具备灵活的容器后端选择和全面的语言支持，从而简化了运行 LLM 生成代码的流程。

文档：https://vndee.github.io/llm-sandbox/

✨ 新增功能：本项目现已支持 模型上下文协议 (MCP) 服务器，使您的 MCP 客户端（如 Claude Desktop）能够在一个安全的沙盒环境中运行 LLM 生成的代码。

🚀 核心功能

🛡️ 安全第一

• 隔离式执行：代码运行于隔离的容器中，无权访问主机系统。
• 安全策略：可自定义安全策略，以严格控制代码的执行。
• 资源限制：可设置 CPU、内存及执行时间的上限。
• 网络隔离：对沙盒化代码的网络访问进行严格管控。

🏗️ 灵活的容器后端

• Docker：最受欢迎且广泛支持的选项。
• Kubernetes：企业级编排工具，适用于可扩展的部署方案。
• Podman：无根容器，提供更强的安全性。

🌐 多语言支持

支持多种编程语言的代码执行，并实现自动依赖管理：

• Python - 全面支持 pip 包管理。
• JavaScript/Node.js - 通过 npm 安装包。
• Java - 使用 Maven 和 Gradle 进行依赖管理。
• C++ - 支持编译与运行。
• Go - 提供模块化支持与编译功能。
• R - 利用 CRAN 包进行统计计算与数据分析。

🔌 LLM 框架集成

可无缝集成到流行的 LLM 框架中，例如 LangChain、LangGraph、LlamaIndex、OpenAI 等。

📊 高阶功能

• 工件提取：自动捕获图表与可视化结果。
• 库管理：即时安装依赖项。
• 文件操作：在沙盒环境中复制文件。
• 自定义镜像：使用您自己的容器镜像。
• 快速生产模式：跳过环境搭建，加快容器启动速度。
• 容器池化：预热并复用容器，提升性能（全新功能！）

📦 安装指南

基础安装

pip install llm-sandbox

配合特定后端支持

# 用于 Docker 支持（最常见）
pip install 'llm-sandbox[docker]'

# 用于 Kubernetes 支持
pip install 'llm-sandbox[k8s]'

# 用于 Podman 支持
pip install 'llm-sandbox[podman]'

# 所有后端
pip install 'llm-sandbox[docker,k8s,podman]'

开发版安装

git clone https://github.com/vndee/llm-sandbox.git
cd llm-sandbox
pip install -e '.[dev]'

🏃‍♂️ 快速上手

基本用法

from llm_sandbox import SandboxSession

# 创建并使用沙盒会话
with SandboxSession(lang="python") as session:
    result = session.run("""
print("来自 LLM 沙盒的问候!")
print("我正在安全的容器中运行。")
    """)
    print(result.stdout)

安装库

from llm_sandbox import SandboxSession

with SandboxSession(lang="python") as session:
    result = session.run("""
import numpy as np

# 创建一个数组
arr = np.array([1, 2, 3, 4, 5])
print(f"数组: {arr}")
print(f"平均值: {np.mean(arr)}")
    """, libraries=["numpy"])

    print(result.stdout)

多语言支持

JavaScript

with SandboxSession(lang="javascript") as session:
    result = session.run("""
const greeting = "来自 Node.js 的问候!";
console.log(greeting);

const axios = require('axios');
console.log("Axios 已成功加载！");
    """, libraries=["axios"])

Java

with SandboxSession(lang="java") as session:
    result = session.run("""
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("来自 Java 的问候!");
    }
}
    """)

C++

with SandboxSession(lang="cpp") as session:
    result = session.run("""
#include <iostream>

int main() {
    std::cout << "来自 C++ 的问候!" << std::endl;
    return 0;
}
    """)

Go

with SandboxSession(lang="go") as session:
    result = session.run("""
package main
import "fmt"

func main() {
    fmt.Println("来自 Go 的问候!")
}
    """)

R

with SandboxSession(
    lang="r",
    image="ghcr.io/vndee/sandbox-r-451-bullseye",
    verbose=True,
) as session:
    result = session.run(
        """
# 基本的 R 操作
print("=== 基本的 R 演示 ===")

# 创建一些数据
numbers <- c(1, 2, 3, 4, 5, 10, 15, 20)
print(paste("数字:", paste(numbers, collapse=", ")))

# 基本统计
print(paste("平均值:", mean(numbers)))
print(paste("中位数:", median(numbers)))
print(paste("标准差:", sd(numbers)))

# 处理数据框
df <- data.frame(
    name = c("Alice", "Bob", "Charlie", "Diana"),
    age = c(25, 30, 35, 28),
    score = c(85, 92, 78, 96)
)

print("=== 数据框 ===")
print(df)

# 计算平均分数
avg_score <- mean(df$score)
print(paste("平均分数:", avg_score))
        """
    )

交互式会话

对于笔记本式的工作流，您可以使用 InteractiveSandboxSession，它能够在多次 run 调用之间保持 Python 解释器的状态。

from llm_sandbox import InteractiveSandboxSession

with InteractiveSandboxSession(
    lang="python",
    kernel_type="ipython",
    history_size=200,
) as session:
    session.run("value = 21 * 2")
    result = session.run("print(f'结果: {value}')")
    print(result.stdout)  # -> 结果: 42

    # 使用魔法命令安装库
    session.run("%pip install pandas")
    result = session.run("import pandas as pd; print(pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]}))")
    print(result.stdout)

交互式会话支持 Docker、Podman 和 Kubernetes 后端，目前主要面向 Python 语言。它们会在沙盒中启动一个长时间运行的 IPython 内核，因此每次 run() 操作都如同在笔记本单元格中执行一样——状态、导入语句以及魔法命令都会一直保留，直到上下文管理器退出，无需额外的网络通信或手动序列化操作。

捕获图表与可视化效果

Python 图表

from llm_sandbox import ArtifactSandboxSession
import base64
from pathlib import Path

with ArtifactSandboxSession(lang="python") as session:
    result = session.run("""
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
y = np.sin(x)

plt.figure(figsize=(10, 6))
plt.plot(x, y)
plt.title("正弦波")
plt.xlabel("x")
plt.ylabel("sin(x)")
plt.grid(True)
plt.savefig("sine_wave.png", dpi=150, bbox_inches="tight")
plt.show()
    """, libraries=["matplotlib", "numpy"])

    # 提取生成的图表
    print(f"生成了 {len(result.plots)} 张图表")

    # 将图表保存为文件
    for i, plot in enumerate(result.plots):
        plot_path = Path(f"plot_{i + 1}.{plot.format.value}")
        with plot_path.open("wb") as f:
            f.write(base64.b64decode(plot.content_base64))

R 图表

from llm_sandbox import ArtifactSandboxSession
import base64
from pathlib import Path

with ArtifactSandboxSession(lang="r") as session:
    result = session.run("""
library(ggplot2)

# 创建示例数据
data <- data.frame(
    x = rnorm(100),
    y = rnorm(100)
)

# 创建 ggplot2 可视化
p <- ggplot(data, aes(x = x, y = y)) +
    geom_point(alpha = 0.6) +
    geom_smooth(method = "lm", se = FALSE) +
    labs(title = "散点图带趋势线",
         x = "X 值", y = "Y 值") +
    theme_minimal()

print(p)

# R 图表
hist(data$x, main = "X 的分布",
     xlab = "X 值", col = "lightblue", breaks = 20)
    """, libraries=["ggplot2"])

    # 提取生成的图表
    print(f"生成了 {len(result.plots)} 张 R 图表")

    # 将图表保存为文件
    for i, plot in enumerate(result.plots):
        plot_path = Path(f"r_plot_{i + 1}.{plot.format.value}")
        with plot_path.open("wb") as f:
            f.write(base64.b64decode(plot.content_base64))

🔧 配置

基本配置

from llm_sandbox import SandboxSession

# 创建一个新的沙盒会话
with SandboxSession(image="python:3.9.19-bullseye", keep_template=True, lang="python") as session:
    result = session.run("print('Hello, World!')")
    print(result)

# 使用自定义 Dockerfile
with SandboxSession(dockerfile="Dockerfile", keep_template=True, lang="python") as session:
    result = session.run("print('Hello, World!')")
    print(result)

# 或者使用默认镜像
with SandboxSession(lang="python", keep_template=True) as session:
    result = session.run("print('Hello, World!')")
    print(result)

LLM 沙盒还支持在主机与沙盒之间复制文件：

from llm_sandbox import SandboxSession

with SandboxSession(lang="python", keep_template=True) as session:
    # 将文件从主机复制到沙盒
    session.copy_to_runtime("test.py", "/sandbox/test.py")

    # 在沙盒中运行复制的 Python 代码
    result = session.execute_command("python /sandbox/test.py")
    print(result)

    # 将文件从沙盒复制回主机
    session.copy_from_runtime("/sandbox/output.txt", "output.txt")

自定义运行时配置

from llm_sandbox import SandboxSession

pod_manifest = {
    "apiVersion": "v1",
    "kind": "Pod",
    "metadata": {
        "name": "test",
        "namespace": "test",
        "labels": {"app": "sandbox"},
    },
    "spec": {
        "containers": [
            {
                "name": "sandbox-container",
                "image": "test",
                "tty": True,
                "volumeMounts": {
                    "name": "tmp",
                    "mountPath": "/tmp",
                }
            }
        ],
        "volumes": [{"name": "tmp", "emptyDir": {"sizeLimit": "5Gi"}}],
    },
}
with SandboxSession(
    backend="kubernetes",
    image="python:3.9.19-bullseye",
    dockerfile=None,
    lang="python",
    keep_template=False,
    verbose=False,
    pod_manifest=pod_manifest,
) as session:
    result = session.run("print('Hello, World!')")
    print(result)

远程 Docker 主机

import docker
from llm_sandbox import SandboxSession

tls_config = docker.tls.TLSConfig(
    client_cert=("path/to/cert.pem", "path/to/key.pem"),
    ca_cert="path/to/ca.pem",
    verify=True
)
docker_client = docker.DockerClient(base_url="tcp://<your_host>:<port>", tls=tls_config)

with SandboxSession(
    client=docker_client,
    image="python:3.9.19-bullseye",
    keep_template=True,
    lang="python",
) as session:
    result = session.run("print('Hello, World!')")
    print(result)

Kubernetes 支持

from kubernetes import client, config
from llm_sandbox import SandboxSession

# 使用本地 kubeconfig
config.load_kube_config()
k8s_client = client.CoreV1Api()

with SandboxSession(
    client=k8s_client,
    backend="kubernetes",
    image="python:3.9.19-bullseye",
    lang="python",
    pod_manifest=pod_manifest, # 默认为 None
) as session:
    result = session.run("print('Hello from Kubernetes!')")
    print(result)

⚠️ 对于自定义 Pod 映射至关重要：

在使用自定义 Pod 映射时，请确保您的容器配置包含以下内容：

• "tty": True（使容器保持存活）
• 在 Pod 和容器层面正确配置 securityContext
• 容器名称可以是任意有效名称（无任何限制）

有关完整要求，请参阅 配置指南。

Podman 支持

from llm_sandbox import SandboxSession

with SandboxSession(
    backend="podman",
    lang="python",
    image="python:3.9.19-bullseye"
) as session:
    result = session.run("print('Hello from Podman!')")
    print(result)

⚡ 容器池化（性能优化）

容器池化通过重复利用预先预热的容器，而非为每次执行创建新容器，从而大幅提升性能。这尤其适用于频繁执行代码的应用程序。

核心优势

• 执行速度更快：消除容器创建的开销，执行速度最高可提升10倍。
• 预热环境：容器在启动时即已加载所需依赖项。
• 线程安全：安全处理并发请求。
• 资源高效：自动管理容器的生命周期。
• 灵活配置：可自定义池大小、超时时间及行为。

基本池使用

from llm_sandbox import SandboxSession
from llm_sandbox.pool import PoolConfig, create_pool_manager

# 明确创建池管理器
pool = create_pool_manager(
    backend="docker",
    config=PoolConfig(
        max_pool_size=10,          # 最大容器数量
        min_pool_size=3,           # 至少保持3个已预热容器
        idle_timeout=300.0,        # 5分钟后回收空闲容器
        enable_prewarming=True,    # 在启动时自动创建容器
    ),
    lang="python",
)

# 在会话中使用池
with SandboxSession(
    lang="python",
    pool=pool,
) as session:
    result = session.run("print('Hello from pool!')")

# 当会话关闭时，容器会自动返回到池中
# 完成操作后，清理池
pool.close()

在多个会话间共享池

为实现最大效率，可将单个池在多个会话间共享：

from llm_sandbox import SandboxSession
from llm_sandbox.pool import create_pool_manager, PoolConfig

# 创建共享池管理器
pool = create_pool_manager(
    backend="docker",
    config=PoolConfig(
        max_pool_size=10,
        min_pool_size=3,
    ),
    lang="python",
    libraries=["numpy", "pandas"],  # 在所有容器中预先安装相关库
)

# 在多个会话中使用池
with SandboxSession(lang="python", pool=pool) as session1:
    result1 = session1.run("import pandas; print(pandas.__version__)")

with SandboxSession(lang="python", pool=pool) as session2:
    result2 = session2.run("import numpy; print(numpy.__version__)")

# 完成操作后，清理池
pool.close()

并发执行

容器池具有线程安全性，并能高效处理并发请求：

from concurrent.futures import ThreadPoolExecutor
from llm_sandbox import SandboxSession
from llm_sandbox.pool import create_pool_manager, PoolConfig

# 创建共享池
pool = create_pool_manager(
    backend="docker",
    config=PoolConfig(max_pool_size=5),
    lang="python",
)

def run_code(task_id: int):
    with SandboxSession(lang="python", pool=pool) as session:
        return session.run(f'print("Task {task_id}")')

try:
    # 使用仅5个容器，同时并发执行20个任务
    with ThreadPoolExecutor(max_workers=10) as executor:
        results = list(executor.map(run_code, range(20)))
finally:
    pool.close()

池配置选项

from llm_sandbox.pool import PoolConfig, ExhaustionStrategy, create_pool_manager

config = PoolConfig(
    # 池大小限制
    max_pool_size=10,                      # 池中的最大容器数量
    min_pool_size=2,                       # 最小的已预热容器数量

    # 超时配置
    idle_timeout=300.0,                    # 回收空闲容器（秒）
    acquisition_timeout=30.0,              # 等待可用容器的时间

    # 运行状态与生命周期
    health_check_interval=60.0,            # 运行状态检查频率
    max_container_lifetime=3600.0,         # 最大容器寿命
    max_container_uses=100,                # 回收前的最大使用次数

    # 池的耗尽策略
    exhaustion_strategy=ExhaustionStrategy.WAIT,  # WAIT、FAIL_FAST 或 TEMPORARY

    # 预热容器
    enable_prewarming=True,                # 预热容器
)

pool = create_pool_manager(
    backend="docker",
    config=config,
    lang="python",
)

池耗尽策略

当所有容器都处于繁忙状态时，池可采用多种方式应对：

1. WAIT（默认）

等待容器空闲：

config = PoolConfig(
    max_pool_size=5,
    exhaustion_strategy=ExhaustionStrategy.WAIT,
    acquisition_timeout=30.0,  # 最多等待30秒
)

2. FAIL_FAST

立即抛出错误：

config = PoolConfig(
    max_pool_size=5,
    exhaustion_strategy=ExhaustionStrategy.FAIL_FAST,
)

3. TEMPORARY

在池外创建临时容器：

config = PoolConfig(
    max_pool_size=5,
    exhaustion_strategy=ExhaustionStrategy.TEMPORARY,
)

监控池统计信息

from llm_sandbox.pool import create_pool_manager

pool = create_pool_manager(backend="docker", lang="python")

# 获取池统计信息
stats = pool.get_stats()
print(f"总容器数: {stats['total_size']}")
print(f"空闲容器数: {stats['state_counts']['idle']}")
print(f"繁忙容器数: {stats['state_counts']['busy']}")

pool.close()

利用池进行工件提取

若需通过容器池捕获图表和可视化效果，可采用以下两种方法：

from llm_sandbox import ArtifactSandboxSession
from llm_sandbox.pool import create_pool_manager, PoolConfig
import base64
from pathlib import Path

# 创建带有预装可视化库的池
pool = create_pool_manager(
    backend="docker",
    config=PoolConfig(max_pool_size=5, min_pool_size=2),
    lang="python",
    libraries=["matplotlib", "numpy"],
)

try:
    # 方法1：利用池参数（推荐用于保持API一致性）
    with ArtifactSandboxSession(pool=pool, enable_plotting=True) as session:
        result = session.run("""
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
y = np.sin(x)
plt.plot(x, y)
plt.title('池化执行 - 正弦波')
plt.show()
        """)

        # 保存生成的图表
        for i, plot in enumerate(result.plots):
            Path(f"plot_{i}.{plot.format.value}").write_bytes(
                base64.b64decode(plot.content_base64)
            )

        print(f"使用池化容器生成了{len(result.plots)}张图表")

    # 方法2：使用ArtifactPooledSandboxSession（显式类）
    # 两种方法的效果完全相同
    from llm_sandbox.pool import ArtifactPooledSandboxSession

    with ArtifactPooledSandboxSession(pool_manager=pool, enable_plotting=True) as session:
        result = session.run("print('功能相同，API不同')")

finally:
    pool.close()

示例

请参阅examples/目录，获取完整演示：

• pool_basic_demo.py - 基础池使用与配置
• pool_concurrent_demo.py - 并发执行模式
• pool_monitoring_demo.py - 运行状态监控与生命周期管理
• pool_artifact_demo.py - 利用池进行工件提取（图表、CSV、混合工件）

🤖 LLM 框架集成

LangChain 工具

from langchain.tools import BaseTool
from llm_sandbox import SandboxSession

class PythonSandboxTool(BaseTool):
    name = "python_sandbox"
    description = "在安全的沙盒环境中执行 Python 代码"

    def _run(self, code: str) -> str:
        with SandboxSession(lang="python") as session:
            result = session.run(code)
            return result.stdout if result.exit_code == 0 else result.stderr

与 OpenAI 函数结合使用

import openai
from llm_sandbox import SandboxSession

def execute_code(code: str, language: str = "python") -> str:
    """在安全的沙盒环境中执行代码"""
    with SandboxSession(lang=language) as session:
        result = session.run(code)
        return result.stdout if result.exit_code == 0 else result.stderr

# 注册为 OpenAI 函数
functions = [
    {
        "name": "execute_code",
        "description": "在安全的沙盒环境中执行代码",
        "parameters": {
            "type": "object",
            "properties": {
                "code": {"type": "string", "description": "要执行的代码"},
                "language": {"type": "string", "enum": ["python", "javascript", "java", "cpp", "go", "r"]}
            },
            "required": ["code"]
        }
    }
]

🔌 模型上下文协议 (MCP) 服务器

LLM 沙盒提供了一个 模型上下文协议 (MCP) 服务器，该服务器使像 Claude Desktop 这样的 AI 助手能够在安全的沙盒环境中安全地执行代码。通过这一集成，LLMs 可以直接运行代码，并自动捕获可视化结果，同时支持多种语言。

特点

• 安全的代码执行：在隔离的容器中执行代码，使用您偏好的后端
• 多语言支持：可运行 Python、JavaScript、Java、C++、Go、R 和 Ruby 代码
• 自动可视化捕获：自动捕获并返回图表和可视化结果
• 库管理：即时安装包和依赖项
• 灵活的后端支持：可选择 Docker、Podman 或 Kubernetes 后端

安装

使用您偏好的后端，安装支持 MCP 的 LLM 沙盒：

# 对于 Docker 后端
pip install 'llm-sandbox[mcp-docker]'

# 对于 Podman 后端
pip install 'llm-sandbox[mcp-podman]'

# 对于 Kubernetes 后端
pip install 'llm-sandbox[mcp-k8s]'

配置

将以下配置添加到您的 MCP 客户端（例如，适用于 Claude Desktop 的 claude_desktop_config.json）：

{
  "mcpServers": {
    "llm-sandbox": {
      "command": "python3",
      "args": ["-m", "llm_sandbox.mcp_server.server"],
    }
  }
}

后端特定配置

对于特定的后端，您需要将 BACKEND 环境变量设置为您希望使用的后端。根据您所使用的后端，可能还需要设置其他环境变量。例如，如果您使用的是 DOCKER_HOST，而系统中未自动包含 DOCKER_HOST，则可能需要设置 DOCKER_HOST 环境变量。

Docker（默认）：

{
  "mcpServers": {
    "llm-sandbox": {
      "command": "python3",
      "args": ["-m", "llm_sandbox.mcp_server.server"],
      "env": {
        "BACKEND": "docker",
        "DOCKER_HOST": "unix:///var/run/docker.sock" // 将此地址更改为实际使用的主机
      }
    }
  }
}

Podman：

{
  "mcpServers": {
    "llm-sandbox": {
      "command": "python3",
      "args": ["-m", "llm_sandbox.mcp_server.server"],
      "env": {
        "BACKEND": "podman",
        "DOCKER_HOST": "unix:///var/run/podman/podman.sock" // 将此地址更改为实际使用的主机
      }
    }
  }
}

对于 Kubernetes，您可能需要将 KUBECONFIG 环境变量设置为您的 kubeconfig 文件路径。

Kubernetes：

{
  "mcpServers": {
    "llm-sandbox": {
      "command": "python3",
      "args": ["-m", "llm_sandbox.mcp_server.server"],
      "env": {
        "BACKEND": "kubernetes",
        "KUBECONFIG": "/path/to/kubeconfig" // 将此地址更改为实际的 kubeconfig 文件路径
      }
    }
  }
}

可用工具

MCP 服务器提供了以下工具：

• execute_code：在安全的沙盒环境中执行代码，并自动捕获可视化结果
• get_supported_languages：获取支持的编程语言列表
• get_language_details：获取特定语言的详细信息

使用示例

配置完成后，您可以请求 AI 助手运行代码，它会自动使用 LLM 沙盒的 MCP 服务器：

“创建一个散点图，展示 x 和 y 数据点之间的关系，使用 matplotlib”

助手将在安全的沙盒中执行 Python 代码，并自动捕获生成的图表或可视化结果。

🏗️ 架构

graph LR
    A[LLM 客户端] --> B[LLM 沙盒]
    B --> C[容器后端]

    A1[OpenAI] --> A
    A2[Anthropic] --> A
    A3[本地 LLMs] --> A
    A4[LangChain] --> A
    A5[LangGraph] --> A
    A6[LlamaIndex] --> A
    A7[MCP 客户端] --> A

    C --> C1[Docker]
    C --> C2[Kubernetes]
    C --> C3[Podman]

    style A fill:#e1f5fe
    style B fill:#f3e5f5
    style C fill:#e8f5e8
    style A1 fill:#fff3e0
    style A2 fill:#fff3e0
    style A3 fill:#fff3e0
    style A4 fill:#fff3e0
    style A5 fill:#fff3e0
    style A6 fill:#fff3e0
    style A7 fill:#fff3e0
    style C1 fill:#e0f2f1
    style C2 fill:#e0f2f1
    style C3 fill:#e0f2f1

📚 文档

• 完整文档 - 全面的文档
• 入门指南 - 安装与基本使用
• 配置指南 - 详细的配置选项
• 安全性 - 安全策略与最佳实践
• 后端 - 容器后端的详细信息
• 语言 - 支持的编程语言
• 集成 - LLM 框架的集成
• API 参考 - 完整的 API 文档
• 示例 - 真实世界的应用示例

🤝 贡献

我们欢迎您的贡献！请参阅我们的 贡献指南 以了解详细信息。

开发设置

# 克隆仓库
git clone https://github.com/vndee/llm-sandbox.git
cd llm-sandbox

# 以开发模式安装
make install

# 运行预提交钩子
uv run pre-commit run -a

# 运行测试
make test

📄 许可证

本项目采用 MIT 许可证——详情请参阅 LICENSE 文件。

🌟 星星历史

如果您觉得 LLM Sandbox 有用，请考虑在 GitHub 上为它点个星！

📞 支持与社区

• GitHub 问题：报告错误或请求功能
• GitHub 讨论区：加入社区
• PyPI：pypi.org/project/llm-sandbox
• 文档：vndee.github.io/llm-sandbox

贡献者

星星历史

llm-sandbox 快速上手指南

环境准备

• 操作系统：Linux / macOS / Windows（需支持 Docker Desktop）
• Python：≥ 3.8
• 容器运行时（任选其一）
  • Docker ≥ 20.10
  • Podman ≥ 4.0
  • Kubernetes 集群（可选）

国内用户建议使用 阿里云镜像加速器 或 DaoCloud 镜像站 加速镜像拉取。

安装步骤

1. 安装容器运行时

   • Docker（推荐）：

     curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun
     sudo systemctl enable --now docker
     

   • Podman（rootless）：

     sudo apt install podman  # Ubuntu/Debian
     

2. 安装 llm-sandbox

   # 基础版本
   pip install llm-sandbox -i https://pypi.tuna.tsinghua.edu.cn/simple
   
   # 带 Docker 后端
   pip install 'llm-sandbox[docker]' -i https://pypi.tuna.tsinghua.edu.cn/simple
   

基本使用

1. 运行 Python 代码

from llm_sandbox import SandboxSession

with SandboxSession(lang="python") as session:
    result = session.run("""
print("你好，LLM Sandbox！")
print("我在隔离容器里安全运行。")
    """)
    print(result.stdout)

2. 自动安装依赖并绘图

from llm_sandbox import ArtifactSandboxSession

with ArtifactSandboxSession(lang="python") as session:
    result = session.run("""
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2*np.pi, 100)
plt.plot(x, np.sin(x))
plt.title("正弦曲线")
plt.savefig("sin.png")
    """, libraries=["matplotlib", "numpy"])

    # 保存生成的图片
    for i, plot in enumerate(result.plots):
        with open(f"plot_{i}.png", "wb") as f:
            f.write(plot.content_base64)

3. 交互式会话（保持状态）

from llm_sandbox import InteractiveSandboxSession

with InteractiveSandboxSession(lang="python") as session:
    session.run("a = 10")
    result = session.run("print(a * 2)")  # 输出 20

完成！现在你已经可以在隔离环境中安全运行 LLM 生成的任何代码了。